WIP

instead of freeCompiler args to avoid snapshotting absolute paths
and fix caching

.bunch

@@ -1,8 +1,7 @@
-191
+193
+201
 192
-183
-182_183
-as33_182_183
-as34_183
-as35
+191_192
+as35_191_192
 as36_192
+as40

.gitignore

@@ -1,8 +1,9 @@
 .DS_Store
 .idea/shelf
-/android.tests.dependencies
 /confluence/target
 /dependencies/repo
+/android.tests.dependencies
+/dependencies/android.tests.dependencies
 /dist
 /local
 /gh-pages
@@ -17,6 +18,7 @@ workspace.xml
 /jps-plugin/testData/kannotator
 /js/js.translator/testData/out/
 /js/js.translator/testData/out-min/
+/js/js.translator/testData/out-pir/
 .gradle/
 build/
 !**/src/**/build
@@ -26,6 +28,7 @@ build/
 .idea/libraries/Gradle*.xml
 .idea/libraries/Maven*.xml
 .idea/artifacts/PILL_*.xml
+.idea/artifacts/KotlinPlugin.xml
 .idea/modules
 .idea/runConfigurations/JPS_*.xml
 .idea/runConfigurations/PILL_*.xml
@@ -47,8 +50,10 @@ build/
 .idea/artifacts/kotlin_main_kts_jar.xml
 .idea/artifacts/kotlin_compiler_client_embeddable_jar.xml
 .idea/artifacts/kotlin_reflect_jar.xml
+.idea/jarRepositories.xml
 kotlin-ultimate/
 node_modules/
 .rpt2_cache/
-libraries/tools/kotlin-test-nodejs-runner/lib/
+libraries/tools/kotlin-test-js-runner/lib/
+libraries/tools/kotlin-source-map-loader/lib/
 local.properties

.idea/artifacts/dist_root.xml

@@ -1,8 +0,0 @@
-<component name="ArtifactManager">
-  <artifact build-on-make="true" name="dist_root">
-    <output-path>$PROJECT_DIR$/dist</output-path>
-    <root id="root">
-      <element id="artifact" artifact-name="dist" />
-    </root>
-  </artifact>
-</component>

.idea/dictionaries/4u7.xml

@@ -1,6 +1,7 @@
 <component name="ProjectDictionaryState">
   <dictionary name="4u7">
     <words>
+      <w>bintray</w>
       <w>cidr</w>
       <w>foldable</w>
       <w>instrumentator</w>

.idea/dictionaries/dmitriy_dolovov.xml

@@ -1,6 +1,11 @@
 <component name="ProjectDictionaryState">
   <dictionary name="dmitriy.dolovov">
     <words>
+      <w>commonization</w>
+      <w>commonize</w>
+      <w>commonized</w>
+      <w>commonizer</w>
+      <w>commonizers</w>
       <w>konan</w>
     </words>
   </dictionary>

.idea/dictionaries/sergey_igushkin.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="sergey.igushkin">
+    <words>
+      <w>klib</w>
+    </words>
+  </dictionary>
+</component>

.idea/dictionaries/skuzmich.xml

@@ -0,0 +1,9 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="skuzmich">
+    <words>
+      <w>anyref</w>
+      <w>ushr</w>
+      <w>wasm</w>
+    </words>
+  </dictionary>
+</component>

.idea/dictionaries/yan.xml

@@ -6,9 +6,13 @@
       <w>destructured</w>
       <w>hacky</w>
       <w>impls</w>
+      <w>inlined</w>
       <w>kapt</w>
+      <w>kotlinc</w>
+      <w>mutators</w>
       <w>parceler</w>
       <w>repl</w>
+      <w>testdata</w>
       <w>uast</w>
       <w>unbox</w>
       <w>unboxed</w>

.idea/inspectionProfiles/idea_default.xml

@@ -99,21 +99,8 @@
       <option name="problems">
         <list>
           <Problem reference="com.intellij.util.JdomKt#element" reason="Removed in 191" />
-          <Problem reference="com.intellij.util.AstLoadingFilter" reason="Absent in 181. Almost all methods were renamed in 183. Use org.jetbrains.kotlin.util.AstLoadingFilter instead." />
-          <Problem reference="com.intellij.codeInspection.reference.RefFile#getPsiElement" reason="Absent in 182. Use psiFile extension instead." />
-          <Problem reference="com.intellij.execution.JavaRunConfigurationExtensionManager#getInstance" reason="Can't be used in Kotlin, because method was replaced with property after J2K in 183. Use JavaRunConfigurationExtensionManagerUtil instead." />
-          <Problem reference="org.jetbrains.java.decompiler.main.decompiler.BaseDecompiler#addSpace" reason="Method was replaced with outher methods in 182. Use addSpaceEx instead." />
-          <Problem reference="com.intellij.execution.configurations.RunConfigurationBase" reason="Generalized in 183. Use RunConfigurationBaseAny instead in signatures." />
-          <Problem reference="com.intellij.execution.configurations.LocatableConfigurationBase" reason="Generalized in 183. Use LocatableConfigurationBaseAny instead in signatures." />
-          <Problem reference="com.intellij.execution.configurations.ModuleBasedConfiguration" reason="Generalized in 183. Use ModuleBasedConfigurationElement instead." />
-          <Problem reference="com.intellij.psi.codeStyle.CodeStyleSettingsProvider" reason="Additional method is introduced in 183 instead of deprecated one. Use CodeStyleSettingsProviderCompat instead." />
-          <Problem reference="com.intellij.openapi.ui.popup.PopupChooserBuilder#PopupChooserBuilder(javax.swing.JList)" reason="Generified in 182. Use PopupChooserBuilderWrapper instead." />
-          <Problem reference="com.intellij.openapi.editor.event.EditorFactoryListener" reason="Default implementations were added in 183. Use EditorFactoryListenerWrapper for inheritance instead." />
-          <Problem reference="com.intellij.openapi.diagnostic.LoggerKt#debugOrInfoIfTestMode" reason="Absent in 182." />
-          <Problem reference="com.intellij.psi.search.PsiSearchHelper.SERVICE" reason="Deprecated since 182. Use psiSearchHelperInstance() instead." />
           <Problem reference="org.jetbrains.kotlin.idea.reporter.ITNReporterCompat#submit" reason="parentComponent is nullable in AS" />
           <Problem reference="com.intellij.diagnostic.ITNReporter#submit" reason="parentComponent is nullable in AS" />
-          <Problem reference="com.intellij.codeInspection.dataFlow.Nullness" reason="Deprecated since 182. Use org.jetbrains.kotlin.idea.util.compat.Nullability instead." />
         </list>
       </option>
     </inspection_tool>
@@ -267,7 +254,7 @@
       <option name="ignoreAnonymousClassMethods" value="false" />
     </inspection_tool>
     <inspection_tool class="MissingRecentApi" enabled="true" level="ERROR" enabled_by_default="true">
-      <option name="sinceBuildString" value="182.0" />
+      <option name="sinceBuildString" value="183.3284" />
       <option name="untilBuildString" value="192.SNAPSHOT" />
     </inspection_tool>
     <inspection_tool class="MisspelledCompareTo" enabled="true" level="WARNING" enabled_by_default="true" />
@@ -436,6 +423,21 @@
     <inspection_tool class="UnnecessaryLabelOnContinueStatement" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="UnnecessaryQualifierForThis" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="UnnecessaryUnboxing" enabled="false" level="WARNING" enabled_by_default="false" />
+    <inspection_tool class="UnstableApiUsage" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="unstableApiAnnotations">
+        <set>
+          <option value="com.google.common.annotations.Beta" />
+          <option value="io.reactivex.annotations.Beta" />
+          <option value="io.reactivex.annotations.Experimental" />
+          <option value="org.apache.http.annotation.Beta" />
+          <option value="org.jetbrains.annotations.ApiStatus.Experimental" />
+          <option value="org.jetbrains.annotations.ApiStatus.Internal" />
+          <option value="org.jetbrains.annotations.ApiStatus.ScheduledForRemoval" />
+          <option value="rx.annotations.Beta" />
+          <option value="rx.annotations.Experimental" />
+        </set>
+      </option>
+    </inspection_tool>
     <inspection_tool class="UseOfPropertiesAsHashtable" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="UtilityClassWithPublicConstructor" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="VolatileLongOrDoubleField" enabled="true" level="WARNING" enabled_by_default="true" />

.idea/misc.xml

@@ -12,46 +12,19 @@
       <item index="2" class="java.lang.String" itemvalue="org.gradle.api.tasks.options.Option" />
     </list>
   </component>
-  <component name="FacetAutodetectingManager">
-    <autodetection-disabled>
-      <facet-type id="Python">
-        <modules>
-          <module name="Jet" />
-        </modules>
-      </facet-type>
-    </autodetection-disabled>
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$" />
   </component>
   <component name="IdProvider" IDEtalkID="71A301FF1940049D6D82F12C40F1E1D5" />
   <component name="JavadocGenerationManager">
-    <option name="OUTPUT_DIRECTORY" />
-    <option name="OPTION_SCOPE" value="protected" />
-    <option name="OPTION_HIERARCHY" value="true" />
-    <option name="OPTION_NAVIGATOR" value="true" />
-    <option name="OPTION_INDEX" value="true" />
-    <option name="OPTION_SEPARATE_INDEX" value="true" />
-    <option name="OPTION_DOCUMENT_TAG_USE" value="false" />
-    <option name="OPTION_DOCUMENT_TAG_AUTHOR" value="false" />
-    <option name="OPTION_DOCUMENT_TAG_VERSION" value="false" />
-    <option name="OPTION_DOCUMENT_TAG_DEPRECATED" value="true" />
-    <option name="OPTION_DEPRECATED_LIST" value="true" />
     <option name="OTHER_OPTIONS" value="" />
-    <option name="HEAP_SIZE" />
-    <option name="LOCALE" />
-    <option name="OPEN_IN_BROWSER" value="true" />
-  </component>
-  <component name="MavenProjectsManager">
-    <option name="originalFiles">
-      <list>
-        <option value="$PROJECT_DIR$/libraries/pom.xml" />
-      </list>
-    </option>
   </component>
   <component name="NullableNotNullManager">
     <option name="myDefaultNullable" value="org.jetbrains.annotations.Nullable" />
     <option name="myDefaultNotNull" value="org.jetbrains.annotations.NotNull" />
     <option name="myNullables">
       <value>
-        <list size="9">
+        <list size="11">
           <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
           <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
           <item index="2" class="java.lang.String" itemvalue="javax.annotation.CheckForNull" />
@@ -61,12 +34,14 @@
           <item index="6" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.Nullable" />
           <item index="7" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableDecl" />
           <item index="8" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableType" />
+          <item index="9" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNullable" />
+          <item index="10" class="java.lang.String" itemvalue="com.android.annotations.Nullable" />
         </list>
       </value>
     </option>
     <option name="myNotNulls">
       <value>
-        <list size="9">
+        <list size="11">
           <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
           <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
           <item index="2" class="java.lang.String" itemvalue="javax.validation.constraints.NotNull" />
@@ -76,6 +51,8 @@
           <item index="6" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.NonNull" />
           <item index="7" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullDecl" />
           <item index="8" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullType" />
+          <item index="9" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNonNull" />
+          <item index="10" class="java.lang.String" itemvalue="com.android.annotations.NonNull" />
         </list>
       </value>
     </option>

.idea/runConfigurations/Generate_Compiler_Tests.xml

@@ -12,6 +12,7 @@
         <list>
           <option value=":compiler:generateTests" />
           <option value=":compiler:tests-java8:generateTests" />
+          <option value=":compiler:tests-against-klib:generateTests" />
           <option value=":js:js.tests:generateTests" />
           <option value=":core:descriptors.runtime:generateTests" />
         </list>

.idea/vcs.xml

@@ -1,5 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="CommitMessageInspectionProfile">
+    <profile version="1.0">
+      <inspection_tool class="BodyLimit" enabled="true" level="WARNING" enabled_by_default="true" />
+      <inspection_tool class="GrazieCommit" enabled="true" level="TYPO" enabled_by_default="true" />
+      <inspection_tool class="SubjectBodySeparation" enabled="true" level="WARNING" enabled_by_default="true" />
+      <inspection_tool class="SubjectLimit" enabled="true" level="WARNING" enabled_by_default="true" />
+    </profile>
+  </component>
   <component name="IssueNavigationConfiguration">
     <option name="links">
       <list>

ChangeLog.md

@@ -1,5 +1,883 @@
 # CHANGELOG
 
+## 1.3.61
+
+### Compiler
+
+- [`KT-35004`](https://youtrack.jetbrains.com/issue/KT-35004) "AssertionError: Unsigned type expected" in `when` range check in extension on unsigned type
+
+### IDE
+
+- [`KT-34923`](https://youtrack.jetbrains.com/issue/KT-34923) [Regression] KtUltraLightMethod.hasModifierProperty("native") returns false for external Kotlin functions
+
+
+### Libraries
+
+- [`KT-21445`](https://youtrack.jetbrains.com/issue/KT-21445) W3C DOM Touch events and interfaces are incomplete / missing
+
+### Tools. Compiler Plugins
+
+- [`KT-34991`](https://youtrack.jetbrains.com/issue/KT-34991) kotlinx.serialization: False warning "Explicit @Serializable annotation on enum class is required when @SerialName or @SerialInfo annotations are used on its members"
+
+### Tools. J2K
+
+- [`KT-34987`](https://youtrack.jetbrains.com/issue/KT-34987) New J2K converter: @NotNull annotations are not removed after converting java code to kotlin
+- [`KT-35074`](https://youtrack.jetbrains.com/issue/KT-35074) J2K: No auto conversion in 'for' loop with multiple init variables
+
+## 1.3.60
+
+### Android
+
+- [`KT-27170`](https://youtrack.jetbrains.com/issue/KT-27170) Android lint tasks fails in Gradle with MPP dependency
+
+### Compiler
+
+#### New Features
+
+- [`KT-31230`](https://youtrack.jetbrains.com/issue/KT-31230) Refine rules for allowed Array-based class literals on different platforms: allow `Array::class` everywhere, disallow `Array<...>::class` on non-JVM
+- [`KT-33413`](https://youtrack.jetbrains.com/issue/KT-33413) Allow 'break' and 'continue' in 'when' statement to point to innermost surrounding loop
+
+#### Performance Improvements
+
+- [`KT-14513`](https://youtrack.jetbrains.com/issue/KT-14513) Suboptimal compilation of lazy delegated properties with inline getValue
+- [`KT-28507`](https://youtrack.jetbrains.com/issue/KT-28507) Extra InlineMarker.mark invocation in generated suspending function bytecode
+- [`KT-29229`](https://youtrack.jetbrains.com/issue/KT-29229) Intrinsify 'in' operator for unsigned integer ranges
+
+#### Fixes
+
+- [`KT-7354`](https://youtrack.jetbrains.com/issue/KT-7354) Confusing error message when trying to access package local java class
+- [`KT-9310`](https://youtrack.jetbrains.com/issue/KT-9310) Don't make interface and DefaultImpls methods synchronized
+- [`KT-11430`](https://youtrack.jetbrains.com/issue/KT-11430) Improve diagnostics for dangling lambdas
+- [`KT-16526`](https://youtrack.jetbrains.com/issue/KT-16526) Provide better error explanation when one tries to delegate var to read-only delegate
+- [`KT-20258`](https://youtrack.jetbrains.com/issue/KT-20258) Improve annotation rendering in diagnostic messages
+- [`KT-22275`](https://youtrack.jetbrains.com/issue/KT-22275) Unify exceptions from null checks
+- [`KT-27503`](https://youtrack.jetbrains.com/issue/KT-27503) Private functions uses from inside of suspendCoroutine go though accessor
+- [`KT-28938`](https://youtrack.jetbrains.com/issue/KT-28938) Coroutines tail-call optimization does not work for generic returns that had instantiated to Unit
+- [`KT-29385`](https://youtrack.jetbrains.com/issue/KT-29385) "AnalyzerException: Expected an object reference, but found I" for EXACTLY_ONCE non-inline contract with captured class constructor parameter
+- [`KT-29510`](https://youtrack.jetbrains.com/issue/KT-29510) "RuntimeException: Trying to access skipped parameter" with EXACTLY_ONCE contract and nested call of crossinline lambda
+- [`KT-29614`](https://youtrack.jetbrains.com/issue/KT-29614) java.lang.VerifyError: Bad type on operand stack  - in inlining,  crossinline in constructor with EXACTLY_ONCE contract
+- [`KT-30275`](https://youtrack.jetbrains.com/issue/KT-30275) Get rid of session in FirElement
+- [`KT-30744`](https://youtrack.jetbrains.com/issue/KT-30744) Invoking Interface Static Method from Extension method generates incorrect jvm bytecode
+- [`KT-30785`](https://youtrack.jetbrains.com/issue/KT-30785) Equality comparison of inline classes results in boxing
+- [`KT-32217`](https://youtrack.jetbrains.com/issue/KT-32217) FIR: support delegated properties resolve
+- [`KT-32433`](https://youtrack.jetbrains.com/issue/KT-32433) NI: UninferredParameterTypeConstructor with class property
+- [`KT-32587`](https://youtrack.jetbrains.com/issue/KT-32587) NI: Type mismatch "String" vs "String" in IDE on generic .invoke on generic delegated property
+- [`KT-32689`](https://youtrack.jetbrains.com/issue/KT-32689) Shuffled line numbers in suspend functions with elvis operator
+- [`KT-32851`](https://youtrack.jetbrains.com/issue/KT-32851) Constraint for callable reference argument doesn't take into account use-site variance
+- [`KT-32864`](https://youtrack.jetbrains.com/issue/KT-32864) The line number of assertFailsWith in suspending function is lost
+- [`KT-33125`](https://youtrack.jetbrains.com/issue/KT-33125) NI: "Rewrite at slice INDEXED_LVALUE_SET" with Mutable Map set index operator inside "@kotlin.BuilderInference" block
+- [`KT-33414`](https://youtrack.jetbrains.com/issue/KT-33414) 'java.lang.AssertionError: int type expected, but null was found in basic frames' in kotlin-io while building library train
+- [`KT-33421`](https://youtrack.jetbrains.com/issue/KT-33421) Please make NOTHING_TO_INLINE warning shorter
+- [`KT-33504`](https://youtrack.jetbrains.com/issue/KT-33504) EA-209823 - ISE: ProjectResolutionFacade$computeModuleResolverProvider$resolverForProject$$.invoke: Can't find builtIns by key CacheKeyBySdk
+- [`KT-33572`](https://youtrack.jetbrains.com/issue/KT-33572) Scripting import with implicit receiver doesn't work
+- [`KT-33821`](https://youtrack.jetbrains.com/issue/KT-33821) Compiler should not rely on the default locale when generating boxing for suspend functions
+- [`KT-18541`](https://youtrack.jetbrains.com/issue/KT-18541) Prohibit "tailrec" modifier on open functions
+- [`KT-19844`](https://youtrack.jetbrains.com/issue/KT-19844) Do not render type annotations on symbols rendered in diagnostic messages
+- [`KT-24913`](https://youtrack.jetbrains.com/issue/KT-24913) KotlinFrontEndException with local class in init of generic class
+- [`KT-28940`](https://youtrack.jetbrains.com/issue/KT-28940) Concurrency issue for lazy values with the post-computation phase
+- [`KT-31540`](https://youtrack.jetbrains.com/issue/KT-31540) Change initialization order of default values for tail recursive optimized functions
+
+### Docs & Examples
+
+- [`KT-26212`](https://youtrack.jetbrains.com/issue/KT-26212) Update docs to explicitly mention that union is opposite of intersect
+- [`KT-34086`](https://youtrack.jetbrains.com/issue/KT-34086) Website, stdlib api docs: unresolved link jvm/stdlib/kotlin.text/-charsets/Charset
+
+### IDE
+
+#### Fixes
+
+- [`KT-8581`](https://youtrack.jetbrains.com/issue/KT-8581) 'Move Statement' doesn't work for statement finished by semicolon
+- [`KT-9204`](https://youtrack.jetbrains.com/issue/KT-9204) Shorten references and some other IDE features have problem when package name clash with class name
+- [`KT-17993`](https://youtrack.jetbrains.com/issue/KT-17993) Annotations are colored the same as language keywords
+- [`KT-21037`](https://youtrack.jetbrains.com/issue/KT-21037) LazyLightClassMemberMatchingError$WrongMatch “Matched :BAR MemberIndex(index=0) to :BAR MemberIndex(index=1) in KtLightClassImpl” after duplicating values inside enum class
+- [`KT-23305`](https://youtrack.jetbrains.com/issue/KT-23305) We should be able to see platform-specific errors in common module
+- [`KT-23461`](https://youtrack.jetbrains.com/issue/KT-23461) `Move statement up/down` attaches a comment block to the function being moved
+- [`KT-26960`](https://youtrack.jetbrains.com/issue/KT-26960) IDE doesn't report `actual` without `expect` placed into a custom platform-agnostic source set
+- [`KT-27243`](https://youtrack.jetbrains.com/issue/KT-27243) LazyLightClassMemberMatchingError when overriding hidden member
+- [`KT-28404`](https://youtrack.jetbrains.com/issue/KT-28404) Gradle configuration page is missing from a New Project Wizard creation flow for multiplatform templates
+- [`KT-30824`](https://youtrack.jetbrains.com/issue/KT-30824) No highlighting of declaration/usage of function with functional-type (lambda) parameter on its usage
+- [`KT-31117`](https://youtrack.jetbrains.com/issue/KT-31117) AssertionError at `CompletionBindingContextProvider._getBindingContext` when typing any character within string with injected Kotlin
+- [`KT-31139`](https://youtrack.jetbrains.com/issue/KT-31139) "Override members" on enum inserts semicolon before enum body
+- [`KT-31810`](https://youtrack.jetbrains.com/issue/KT-31810) Paste inside indented `.trimIndent()` raw string doesn't respect indentation
+- [`KT-32401`](https://youtrack.jetbrains.com/issue/KT-32401) Exceptions while running IDEA in headless mode for building searchable options
+- [`KT-32543`](https://youtrack.jetbrains.com/issue/KT-32543) UltraLight support for Kotlin collections.
+- [`KT-32544`](https://youtrack.jetbrains.com/issue/KT-32544) Support UltraLight classes for local/anonymous/enum classes
+- [`KT-32799`](https://youtrack.jetbrains.com/issue/KT-32799) 2019.2 RC (192.5728.74) Kotlin plugin exception during build searchable options (Directory index may not be queried for default project)
+- [`KT-33008`](https://youtrack.jetbrains.com/issue/KT-33008) IDEA does not report in MPP: Upper bound of a type parameter cannot be an array
+- [`KT-33316`](https://youtrack.jetbrains.com/issue/KT-33316) Kotlin Facet: make sure the order of allPlatforms value is fixed
+- [`KT-33561`](https://youtrack.jetbrains.com/issue/KT-33561) LazyLightClassMemberMatchingError when overloading synthetic member
+- [`KT-33584`](https://youtrack.jetbrains.com/issue/KT-33584) Make kotlin light classes return no-arg constructor when no-arg (or jpa) compiler plugin is enabled
+- [`KT-33775`](https://youtrack.jetbrains.com/issue/KT-33775) please remove usages of org.intellij.plugins.intelliLang.inject.InjectorUtils#putInjectedFileUserData(com.intellij.lang.injection.MultiHostRegistrar, com.intellij.openapi.util.Key<T>, T) deprecated eons ago
+- [`KT-33813`](https://youtrack.jetbrains.com/issue/KT-33813) Poor formatting of 'Selected target platforms' and 'Depends on' in facet settings
+- [`KT-33937`](https://youtrack.jetbrains.com/issue/KT-33937) delay() completion from kotlinx.coroutines causes happening of root package in code
+- [`KT-33973`](https://youtrack.jetbrains.com/issue/KT-33973) Kotlin objects could abuse idea plugin functionality
+- [`KT-34000`](https://youtrack.jetbrains.com/issue/KT-34000) Import quickfix does not work for extension methods from objects
+- [`KT-34070`](https://youtrack.jetbrains.com/issue/KT-34070) "No target platforms selected" message for commonTest facet at mobile shared library project
+- [`KT-34191`](https://youtrack.jetbrains.com/issue/KT-34191) Since-build .. until-build compatibility ranges are the same for 192 and 193 IDE plugins
+- [`KT-21153`](https://youtrack.jetbrains.com/issue/KT-21153) IDE: string template + annotation usage: ISE: "Couldn't get delegate" at LightClassDataHolderKt.findDelegate()
+- [`KT-33352`](https://youtrack.jetbrains.com/issue/KT-33352) "KotlinExceptionWithAttachments: Couldn't get delegate for class" on nested class/object
+- [`KT-34042`](https://youtrack.jetbrains.com/issue/KT-34042) "Error loading Kotlin facets. Kotlin facets are not allowed in Kotlin/Native Module" in 192 IDEA
+- [`KT-34237`](https://youtrack.jetbrains.com/issue/KT-34237) MPP with Android target: `common*` source sets are not shown as source roots in IDE
+- [`KT-33626`](https://youtrack.jetbrains.com/issue/KT-33626) Deadlock with Kotlin LockBasedStorageManager in IDEA commit dialog
+- [`KT-34402`](https://youtrack.jetbrains.com/issue/KT-34402) Unresolved reference to Kotlin.test library in CommonTest in Multiplatform project without JVM target
+- [`KT-34639`](https://youtrack.jetbrains.com/issue/KT-34639) Multiplatform project with the only (Android) target is incorrectly imported into IDE
+
+### IDE. Completion
+
+- [`KT-10340`](https://youtrack.jetbrains.com/issue/KT-10340) Import completion unable to shorten fq-names when there is a conflict between package name and local identifier
+- [`KT-17689`](https://youtrack.jetbrains.com/issue/KT-17689) Code completion for enum typealias doesn't show members
+- [`KT-28998`](https://youtrack.jetbrains.com/issue/KT-28998) Slow completion for build.gradle.kts (Kotlin Gradle DSL script)
+- [`KT-30996`](https://youtrack.jetbrains.com/issue/KT-30996) DSL extension methods which are not applicable are offered for completion
+- [`KT-31902`](https://youtrack.jetbrains.com/issue/KT-31902) Fully qualified name is used for `delay` instead of  import and just method name
+- [`KT-33903`](https://youtrack.jetbrains.com/issue/KT-33903) Duplicating completion for imported extensions from companion objects
+
+### IDE. Debugger
+
+- [`KT-10984`](https://youtrack.jetbrains.com/issue/KT-10984) Disallow placing line breakpoints without executable code (changed)
+- [`KT-22116`](https://youtrack.jetbrains.com/issue/KT-22116) Support function breakpoints
+- [`KT-24408`](https://youtrack.jetbrains.com/issue/KT-24408) @InlineOnly: Misleading status for breakpoints in inline functions
+- [`KT-27645`](https://youtrack.jetbrains.com/issue/KT-27645) Debugger breakpoints do not work in suspend function executed in SpringBoot controller (MVC and WebFlux)
+- [`KT-32687`](https://youtrack.jetbrains.com/issue/KT-32687) Disallow breakpoints for @InlineOnly function bodies
+- [`KT-32813`](https://youtrack.jetbrains.com/issue/KT-32813) Exception on invoking "Smart Step Into"
+- [`KT-32830`](https://youtrack.jetbrains.com/issue/KT-32830) NPE on changing class property in Evaluate Expression window
+- [`KT-33064`](https://youtrack.jetbrains.com/issue/KT-33064) “Read access is allowed from event dispatch thread or inside read-action only” from KotlinLineBreakpointType.createLineSourcePosition on adding new line before the current one while stopping on breakpoint
+- [`KT-11395`](https://youtrack.jetbrains.com/issue/KT-11395) Breakpoint inside lambda argument of InlineOnly function doesn't work
+
+### IDE. Folding
+
+- [`KT-6314`](https://youtrack.jetbrains.com/issue/KT-6314) Folding of "when" construction
+
+### IDE. Gradle
+
+- [`KT-33038`](https://youtrack.jetbrains.com/issue/KT-33038) Package prefix is not imported in non-MPP project
+- [`KT-33987`](https://youtrack.jetbrains.com/issue/KT-33987) Serialization exception during importing Kotlin project in IDEA 192
+- [`KT-32960`](https://youtrack.jetbrains.com/issue/KT-32960) KotlinMPPGradleModelBuilder takes a long time to process when syncing non-MPP project with IDE
+- [`KT-34424`](https://youtrack.jetbrains.com/issue/KT-34424) With Kotlin plugin in Gradle project without Native the IDE fails to start Gradle task: "Kotlin/Native properties file is absent at null/konan/konan.properties"
+- [`KT-34256`](https://youtrack.jetbrains.com/issue/KT-34256) Fail to use multiplatform modules with dependsOn with android plugin
+- [`KT-34663`](https://youtrack.jetbrains.com/issue/KT-34663) Low performance of MPP 1.2 during import with module-per-source-set enabled
+
+### IDE. Gradle. Script
+
+- [`KT-31766`](https://youtrack.jetbrains.com/issue/KT-31766) Gradle Kotlin DSL new project template: use type-safe model accessors
+- [`KT-34463`](https://youtrack.jetbrains.com/issue/KT-34463) New Gradle-based project template misses pluginManagement{} block in EAP branch
+- [`KT-31767`](https://youtrack.jetbrains.com/issue/KT-31767) Gradle Kotlin DSL new project template: use settings.gradle.kts
+
+### IDE. Inspections and Intentions
+
+#### New Features
+
+- [`KT-26431`](https://youtrack.jetbrains.com/issue/KT-26431) Quickfix to remove redundant label
+- [`KT-28049`](https://youtrack.jetbrains.com/issue/KT-28049) Suggest import quickfix for operator extension functions
+- [`KT-29622`](https://youtrack.jetbrains.com/issue/KT-29622) "Move to separate file" intention should also work for sealed class
+- [`KT-33178`](https://youtrack.jetbrains.com/issue/KT-33178) Use a new compiler flag -Xinline-classes during enabling the feature via IDEA intention
+- [`KT-33586`](https://youtrack.jetbrains.com/issue/KT-33586) "Constructors are not allowed for objects" diagnostic needs quickfix to change object to class
+
+#### Fixes
+
+- [`KT-12291`](https://youtrack.jetbrains.com/issue/KT-12291) Override/Implement Members: better member positioning inside the class
+- [`KT-14899`](https://youtrack.jetbrains.com/issue/KT-14899) Quickfix "Create member function" inserts too many semicolons when applied to Enum
+- [`KT-15700`](https://youtrack.jetbrains.com/issue/KT-15700) "Convert lambda to reference" does not work with backtick-escaped references
+- [`KT-18772`](https://youtrack.jetbrains.com/issue/KT-18772) "Introduce subject to when": don't choose an object or a constant as the subject
+- [`KT-21172`](https://youtrack.jetbrains.com/issue/KT-21172) Join declaration and assignment should place the result at the assignment, not at declaration
+- [`KT-25697`](https://youtrack.jetbrains.com/issue/KT-25697) `Replace with dot call` quickfix breaks formatting
+- [`KT-26635`](https://youtrack.jetbrains.com/issue/KT-26635) An empty line is added after `actual` modifier on "Create actual annotation class..." quick fix applied to annotation if it is annotated with comment
+- [`KT-27270`](https://youtrack.jetbrains.com/issue/KT-27270) "Add jar to classpath" quick fix modifies build.gradle of MPP project in a way that fails to be imported
+- [`KT-28471`](https://youtrack.jetbrains.com/issue/KT-28471) "Add initializer" quickfix initializes non-null variable with null
+- [`KT-28538`](https://youtrack.jetbrains.com/issue/KT-28538) `create expected ...` quick fix illegally creates `expect` member with a usage of a platform-specific type
+- [`KT-28549`](https://youtrack.jetbrains.com/issue/KT-28549) Create actual/expect quick fix for class/object doesn't add import for an inherited member
+- [`KT-28620`](https://youtrack.jetbrains.com/issue/KT-28620) `Create expect/actual ...` quick fix could save @Test annotation on generation
+- [`KT-28740`](https://youtrack.jetbrains.com/issue/KT-28740) AE “2 declarations in var bar: [ERROR : No type, no body]” after applying “Create actual class” quick fix for class with property which has not specified type
+- [`KT-28947`](https://youtrack.jetbrains.com/issue/KT-28947) Backing field has created after applying “Create expected class in common module...” intention
+- [`KT-30136`](https://youtrack.jetbrains.com/issue/KT-30136) False negative "Redundant explicit 'this'" with local variable
+- [`KT-30794`](https://youtrack.jetbrains.com/issue/KT-30794) Quickfix for unchecked cast produces invalid code
+- [`KT-31133`](https://youtrack.jetbrains.com/issue/KT-31133) Liveness analysis on enum does not take into account calls to 'values'
+- [`KT-31433`](https://youtrack.jetbrains.com/issue/KT-31433) Incorrect "Create expected class..." for class with supertype
+- [`KT-31475`](https://youtrack.jetbrains.com/issue/KT-31475) "Create expect..." should delete 'override' modifier
+- [`KT-31587`](https://youtrack.jetbrains.com/issue/KT-31587) Redundant `private` modifier before primary constructor after create `actual` class
+- [`KT-31921`](https://youtrack.jetbrains.com/issue/KT-31921) "Create expected ..."/"Create actual..." quick fix: `val` and `vararg` modifiers are misordered in the generated `expect`/`actual` declaration
+- [`KT-31999`](https://youtrack.jetbrains.com/issue/KT-31999) "Variable declaration could be moved into `when`" inspection suggests to inline expression containing return (throw) statement
+- [`KT-32012`](https://youtrack.jetbrains.com/issue/KT-32012) Change parameter type quick fix: Don't use qualified name
+- [`KT-32468`](https://youtrack.jetbrains.com/issue/KT-32468) False positive SimplifiableCall "filter call could be simplified to filterIsInstance" with expression body function and explicit return type
+- [`KT-32479`](https://youtrack.jetbrains.com/issue/KT-32479) False positive "Redundant overriding method" with derived property and base function starting with `get`, `set` or `is` (Accidental override)
+- [`KT-32571`](https://youtrack.jetbrains.com/issue/KT-32571) "Create expect" quick fix incorrectly treats multiplatform stdlib typealiased types as platform-specific ones
+- [`KT-32580`](https://youtrack.jetbrains.com/issue/KT-32580) "Remove braces" QF for single-expression function with inferred lambda return type: "ClassCastException: class kotlin.reflect.jvm.internal.KClassImpl cannot be cast to class kotlin.jvm.internal.ClassBasedDeclarationContainer"
+- [`KT-32582`](https://youtrack.jetbrains.com/issue/KT-32582) Ambiguous message for [AMBIGUOUS_ACTUALS] error (master)
+- [`KT-32586`](https://youtrack.jetbrains.com/issue/KT-32586) "Make member open" quick fix doesn't update all the related actualisations of an expected member
+- [`KT-32616`](https://youtrack.jetbrains.com/issue/KT-32616) "To ordinary string literal" doesn't remove indents, newlines and `trimIndent`
+- [`KT-32642`](https://youtrack.jetbrains.com/issue/KT-32642) "Create expect" quick fix doesn't warn about a platform-specific annotation applied to the generated member
+- [`KT-32650`](https://youtrack.jetbrains.com/issue/KT-32650) "Replace 'if' with 'when'" removes braces from 'if' statement
+- [`KT-32694`](https://youtrack.jetbrains.com/issue/KT-32694) "Create expect"/"create actual" quick fix doesn't transfer use-site annotations
+- [`KT-32737`](https://youtrack.jetbrains.com/issue/KT-32737) "Create expect" quick fix adds `actual` modifier to an interface function with default implementation without a warning
+- [`KT-32768`](https://youtrack.jetbrains.com/issue/KT-32768) "Create expect" quick fix doesn't warn about a local supertype of an `actual` class while generating an expected declaration
+- [`KT-32829`](https://youtrack.jetbrains.com/issue/KT-32829) "Add .jar to the classpath" quick fix creates "compile"/"testCompile" dependencies in build.gradle
+- [`KT-32972`](https://youtrack.jetbrains.com/issue/KT-32972) No "remove braces" inspection for ${this}
+- [`KT-32981`](https://youtrack.jetbrains.com/issue/KT-32981) "Create enum constant" quick fix adds redundant empty line
+- [`KT-33060`](https://youtrack.jetbrains.com/issue/KT-33060) "Cleanup code" does not remove 'final' keyword for overridden function with non-canonical modifiers order
+- [`KT-33115`](https://youtrack.jetbrains.com/issue/KT-33115) "Replace overloaded operator with function call" intention should not be shown on incomplete expressions
+- [`KT-33150`](https://youtrack.jetbrains.com/issue/KT-33150) Don't suggest create expect function from function with `private` modifier
+- [`KT-33153`](https://youtrack.jetbrains.com/issue/KT-33153) False positive "Redundant overriding method" when overriding package private method
+- [`KT-33204`](https://youtrack.jetbrains.com/issue/KT-33204) False positive "flatMap call could be simplified to flatten()" with Array
+- [`KT-33299`](https://youtrack.jetbrains.com/issue/KT-33299) "Create type parameter from usage" should work with backticks
+- [`KT-33300`](https://youtrack.jetbrains.com/issue/KT-33300) "Create type parameter from usage" suggests for top level property
+- [`KT-33302`](https://youtrack.jetbrains.com/issue/KT-33302) KNPE after "Create type parameter from usage" with typealias
+- [`KT-33357`](https://youtrack.jetbrains.com/issue/KT-33357) 'java.lang.Throwable: Assertion failed: Refactorings should be invoked inside transaction 'exception occurs when extracting sealed class from file with the same name
+- [`KT-33362`](https://youtrack.jetbrains.com/issue/KT-33362) Inspection "Extract class from current file" is not available for 'sealed' keyword
+- [`KT-33437`](https://youtrack.jetbrains.com/issue/KT-33437) “Argument rangeInElement (0,1) endOffset must not exceed descriptor text range (0, 0) length (0).” on creating Kotlin Script files inside package
+- [`KT-33612`](https://youtrack.jetbrains.com/issue/KT-33612) "Replace with safe call" quick fix moves code to another line
+- [`KT-33660`](https://youtrack.jetbrains.com/issue/KT-33660) "Convert to anonymous object" with nested SAM interface inserts `object` keyword in the wrong place
+- [`KT-33718`](https://youtrack.jetbrains.com/issue/KT-33718) "Create enum constant" quick fix adds after semicolon
+- [`KT-33754`](https://youtrack.jetbrains.com/issue/KT-33754) Improve error hint message for "Create expect/actual..."
+- [`KT-33880`](https://youtrack.jetbrains.com/issue/KT-33880) "Convert to range check" produces code that is subject to ReplaceRangeToWithUntil for range with exclusive upper bound
+- [`KT-33930`](https://youtrack.jetbrains.com/issue/KT-33930) Don't suggest "create expect" quick fix on `lateinit` and `const` top-level properties
+- [`KT-33981`](https://youtrack.jetbrains.com/issue/KT-33981) “KotlinCodeInsightWorkspaceSettings is registered as application service, but requested as project one” on opening QF menu for some fixes in IJ193
+- [`KT-32965`](https://youtrack.jetbrains.com/issue/KT-32965) False positive "Redundant qualifier name" with nested enum member call
+- [`KT-33597`](https://youtrack.jetbrains.com/issue/KT-33597) False positive "Redundant qualifier name" with class property initialized with same-named object property
+- [`KT-33991`](https://youtrack.jetbrains.com/issue/KT-33991) False positive "Redundant qualifier name" with enum member function call
+- [`KT-34113`](https://youtrack.jetbrains.com/issue/KT-34113) False positive "Redundant qualifier name" with Enum.values() from a different Enum
+
+### IDE. KDoc
+
+- [`KT-20777`](https://youtrack.jetbrains.com/issue/KT-20777) KDoc: Type parameters are not shown in sample code
+
+### IDE. Multiplatform
+
+- [`KT-26333`](https://youtrack.jetbrains.com/issue/KT-26333) IDE incorrectly requires `actual` implementations to be present in all the project source sets
+- [`KT-28537`](https://youtrack.jetbrains.com/issue/KT-28537) Platform-specific type taken from a dependency module isn't reported in `common` code
+- [`KT-32562`](https://youtrack.jetbrains.com/issue/KT-32562) Provide a registry key to enable/disable hierarchical multiplatform mechanism in IDE
+
+### IDE. Navigation
+
+- [`KT-28075`](https://youtrack.jetbrains.com/issue/KT-28075) Duplicate "implements" gutter icons on some interfaces
+- [`KT-30052`](https://youtrack.jetbrains.com/issue/KT-30052) Duplicated "is subclassed" editor gutter icons
+- [`KT-33182`](https://youtrack.jetbrains.com/issue/KT-33182) com.intellij.idea.IdeStarter#main has four (!) icons, should be two
+
+### IDE. REPL
+
+- [`KT-33329`](https://youtrack.jetbrains.com/issue/KT-33329) IllegalArgumentException in REPL
+
+### IDE. Refactorings
+
+- [`KT-24929`](https://youtrack.jetbrains.com/issue/KT-24929) 'Search for references' checkbox state isn't saved on move of kotlin file
+- [`KT-30342`](https://youtrack.jetbrains.com/issue/KT-30342) Move refactoring: suggest file name starting with an uppercase letter
+- [`KT-32426`](https://youtrack.jetbrains.com/issue/KT-32426) Invalid code format after "Pull Members Up" on function with comment and another indent
+- [`KT-32496`](https://youtrack.jetbrains.com/issue/KT-32496) "Problems Detected" dialog message about conflicting declarations on moving file to another package is absolutely unreadable
+- [`KT-33059`](https://youtrack.jetbrains.com/issue/KT-33059) Exception [Assertion failed: Write access is allowed inside write-action only] in case of Move class to nonexistent folder
+- [`KT-33972`](https://youtrack.jetbrains.com/issue/KT-33972) Change signature should affect all hierarchy
+
+### IDE. Run Configurations
+
+- [`KT-34366`](https://youtrack.jetbrains.com/issue/KT-34366) Implement gutters for running tests (multi-platform projects)
+
+### IDE. Scratch
+
+- [`KT-23986`](https://youtrack.jetbrains.com/issue/KT-23986) No access to stdout output in Kotlin scratch
+- [`KT-23989`](https://youtrack.jetbrains.com/issue/KT-23989) Scratch: allow copy of a scratch output
+- [`KT-28910`](https://youtrack.jetbrains.com/issue/KT-28910) Add hint for Make before Run checkbox
+- [`KT-29407`](https://youtrack.jetbrains.com/issue/KT-29407) strange output for long strings
+- [`KT-31295`](https://youtrack.jetbrains.com/issue/KT-31295) Kotlin worksheet in projects, not as scratch files
+- [`KT-32366`](https://youtrack.jetbrains.com/issue/KT-32366) Sidebar as alternative output layout
+- [`KT-33585`](https://youtrack.jetbrains.com/issue/KT-33585) Synchronized highlighting of the main editor and side panel
+
+### IDE. Script
+
+- [`KT-30206`](https://youtrack.jetbrains.com/issue/KT-30206) Settings / ... / Kotlin Scripting with no project opened causes ISE: "project.baseDir must not be null" at ScriptTemplatesFromDependenciesProvider.loadScriptDefinitions()
+- [`KT-32513`](https://youtrack.jetbrains.com/issue/KT-32513) Intellij hangs in ApplicationUtilsKt.runWriteAction through ScriptDependenciesLoader$submitMakeRootsChange$doNotifyRootsChanged$1.run
+
+### IDE. Wizards
+
+- [`KT-27587`](https://youtrack.jetbrains.com/issue/KT-27587) Bump Android build tools version at `Multiplatform (Android/iOS)` template of the New Project Wizard
+- [`KT-33927`](https://youtrack.jetbrains.com/issue/KT-33927) MPP, Kotlin New project wizard: broken project generation
+- [`KT-34108`](https://youtrack.jetbrains.com/issue/KT-34108) Gradle Kotlin DSL: generated project with `tasks` element fails on configuration stage with Gradle 4.10
+- [`KT-34154`](https://youtrack.jetbrains.com/issue/KT-34154) New Project wizard: build.gradle.kts: type-safe code sets JVM 1.8 for main, but JVM 1.6 for test
+- [`KT-34229`](https://youtrack.jetbrains.com/issue/KT-34229) New Project wizard: IDEA 193+: Mobile Android/iOS: creating another project of this type tries to write into previous one
+
+### JavaScript
+
+- [`KT-12935`](https://youtrack.jetbrains.com/issue/KT-12935) Generated source maps for JS mention nonexistent dummy.kt
+- [`KT-26701`](https://youtrack.jetbrains.com/issue/KT-26701) JS, rollup.js: Application can't depend on a library if both sourcemaps reference "dummy.kt"
+
+### Libraries
+
+- [`KT-26309`](https://youtrack.jetbrains.com/issue/KT-26309) Avoid division in string-to-number conversions
+- [`KT-27545`](https://youtrack.jetbrains.com/issue/KT-27545) File.copyTo: unclear error message when it fails to delete the destination
+- [`KT-28804`](https://youtrack.jetbrains.com/issue/KT-28804) Wrong parameter name in kotlin.text.contentEquals
+- [`KT-32024`](https://youtrack.jetbrains.com/issue/KT-32024) Modify `Iterable<T>.take(n)` implementation not to call `.next()` more than necessary
+- [`KT-32532`](https://youtrack.jetbrains.com/issue/KT-32532) MutableList<T>.removeAll is lacking documentation
+- [`KT-32728`](https://youtrack.jetbrains.com/issue/KT-32728) CollectionsKt.windowed throws IllegalArgumentException (Illegal Capacity: -1) when size param is Integer.MAX_VALUE due to overflow operation
+- [`KT-33864`](https://youtrack.jetbrains.com/issue/KT-33864) Read from pseudo-file system is empty
+
+### Reflection
+
+- [`KT-13936`](https://youtrack.jetbrains.com/issue/KT-13936) KotlinReflectionInternalError on invoking callBy on overridden member with inherited default argument value
+- [`KT-17860`](https://youtrack.jetbrains.com/issue/KT-17860) Improve KParameter.toString for receiver parameters
+
+### Tools
+
+- [`KT-17045`](https://youtrack.jetbrains.com/issue/KT-17045) Drop MaxPermSize support from compiler daemon
+- [`KT-32259`](https://youtrack.jetbrains.com/issue/KT-32259) `org.jetbrains.annotations` module exported from embeddable compiler, causes problems in Java modular builds
+
+### Tools. Android Extensions
+
+- [`KT-32096`](https://youtrack.jetbrains.com/issue/KT-32096) IDE plugin doesn't recognize that Parcelize is no longer experimental
+
+### Tools. CLI
+
+- [`KT-24991`](https://youtrack.jetbrains.com/issue/KT-24991) CLI: Empty classpath in `kotlin` script except for `kotlin-runner.jar`
+- [`KT-26624`](https://youtrack.jetbrains.com/issue/KT-26624) Set Thread.contextClassLoader when running programs with 'kotlin' launcher script or scripts with 'kotlinc -script'
+- [`KT-24966`](https://youtrack.jetbrains.com/issue/KT-24966) Classloader problems when running basic kafka example with `kotlin` and `kotlinc`
+
+### Tools. Compiler Plugins
+
+- [`KT-29471`](https://youtrack.jetbrains.com/issue/KT-29471) output from jvm-api-gen plugin on classpath crashes downstream kotlinc-jvm: inline method with inner class
+- [`KT-33630`](https://youtrack.jetbrains.com/issue/KT-33630) cannot use @kotlinx.serialization.Transient and lateinit together on 1.3.50
+
+### Tools. Daemon
+
+- [`KT-32992`](https://youtrack.jetbrains.com/issue/KT-32992) Enable assertions in Kotlin Compile Daemon
+- [`KT-33027`](https://youtrack.jetbrains.com/issue/KT-33027) Compilation with daemon fails, because IncrementalModuleInfo#serialVersionUID does not match
+
+### Tools. Gradle
+
+#### New Features
+
+- [`KT-20760`](https://youtrack.jetbrains.com/issue/KT-20760) Kotlin Gradle Plugin doesn't allow for configuring friend paths through API
+- [`KT-34009`](https://youtrack.jetbrains.com/issue/KT-34009) Associate compilations in the target–compilation project model
+
+#### Performance Improvements
+
+- [`KT-31666`](https://youtrack.jetbrains.com/issue/KT-31666) Kotlin plugin configures all tasks in a project when `kotlin.incremental` is enabled
+
+#### Fixes
+
+- [`KT-17630`](https://youtrack.jetbrains.com/issue/KT-17630) User test Gradle source set code cannot reach out internal members from the production code
+- [`KT-22213`](https://youtrack.jetbrains.com/issue/KT-22213) Android Extensions experimental mode doesn't work with Gradle Kotlin DSL
+- [`KT-31077`](https://youtrack.jetbrains.com/issue/KT-31077) android.kotlinOptions block is lacking its type
+- [`KT-31641`](https://youtrack.jetbrains.com/issue/KT-31641) Kapt configurations miss attributes to resolve MPP dependencies: Cannot choose between the following variants ...
+- [`KT-31713`](https://youtrack.jetbrains.com/issue/KT-31713) ConcurrentModificationException: Realize Pending during execution phase
+- [`KT-32678`](https://youtrack.jetbrains.com/issue/KT-32678) Bugfixes in HMPP source set visibility
+- [`KT-32679`](https://youtrack.jetbrains.com/issue/KT-32679) Testing & test tasks API in the target–compilation model
+- [`KT-32804`](https://youtrack.jetbrains.com/issue/KT-32804) Kapt-generated Java sources in jvm+withJava MPP module are not compiled and bundled
+- [`KT-32853`](https://youtrack.jetbrains.com/issue/KT-32853) ConcurrentModificationException when compiling with Gradle.
+- [`KT-32872`](https://youtrack.jetbrains.com/issue/KT-32872) Gradle test runner for Native does not show failed build if process quit without starting printing results.
+- [`KT-33105`](https://youtrack.jetbrains.com/issue/KT-33105) kapt+withJava in multiplatform module depending on other multiplatform fails on 1.3.50-eap-54
+- [`KT-33469`](https://youtrack.jetbrains.com/issue/KT-33469) Drop support for Gradle versions older than 4.3 in the Kotlin Gradle plugin
+- [`KT-33470`](https://youtrack.jetbrains.com/issue/KT-33470) Drop support for Gradle versions older than 4.9 in the Kotlin Gradle plugin
+- [`KT-33980`](https://youtrack.jetbrains.com/issue/KT-33980) Read the granular source sets metadata flag value once and cache it for the current Gradle build
+- [`KT-34312`](https://youtrack.jetbrains.com/issue/KT-34312) UnsupportedOperationException on `requiresVisibilityOf` in the Kotlin Gradle plugin
+
+### Tools. Gradle. JS
+
+#### New Features
+
+- [`KT-31478`](https://youtrack.jetbrains.com/issue/KT-31478) Gradle, JS tests, Karma: Support sourcemaps in Gradle stacktraces
+- [`KT-32073`](https://youtrack.jetbrains.com/issue/KT-32073) Gradle, JS, karma: parse errors and warnings from karma output
+- [`KT-32075`](https://youtrack.jetbrains.com/issue/KT-32075) Gradle, JS, karma: download chrome headless using puppeteer
+
+#### Fixes
+
+- [`KT-31663`](https://youtrack.jetbrains.com/issue/KT-31663) Gradle/JS: with not installed browser specified for browser test the response is "Successful, 0 tests found"
+- [`KT-32216`](https://youtrack.jetbrains.com/issue/KT-32216) Gradle, JS, tests: filter doesn't work
+- [`KT-32224`](https://youtrack.jetbrains.com/issue/KT-32224) In Gradle Kotlin/JS projects, the `browserWebpack` task does not rerun when the `main` compilation's outputs change
+- [`KT-32281`](https://youtrack.jetbrains.com/issue/KT-32281) Gradle, JS, karma: Headless chrome output is not captured
+- [`KT-33288`](https://youtrack.jetbrains.com/issue/KT-33288) JS: Incorrect bundle with webpack output.library and source maps
+- [`KT-33313`](https://youtrack.jetbrains.com/issue/KT-33313) When a Kotlin/JS test task runs using a custom compilation, it doesn't track the compilation outputs in its up-to-date checks
+- [`KT-33547`](https://youtrack.jetbrains.com/issue/KT-33547) Template JS Client and JVM Server works wrong on 1.3.50 Kotlin
+- [`KT-33549`](https://youtrack.jetbrains.com/issue/KT-33549) Gradle Kotlin/JS external declarations: search for `typings` key inside `package.json`
+- [`KT-33579`](https://youtrack.jetbrains.com/issue/KT-33579) Js tests with mocha cannot be run
+- [`KT-33710`](https://youtrack.jetbrains.com/issue/KT-33710) Task "generateExternals" for automatic Dukat execution does not work
+- [`KT-33716`](https://youtrack.jetbrains.com/issue/KT-33716) Gradle, Yarn: yarn is not downloading via YarnSetupTask
+- [`KT-34101`](https://youtrack.jetbrains.com/issue/KT-34101) CCE class org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest_Decorated cannot be cast to class org.gradle.api.provider.Provider on importing Gradle project with JS
+- [`KT-34123`](https://youtrack.jetbrains.com/issue/KT-34123) "Cannot find node module "kotlin-test-js-runner/kotlin-test-karma-runner.js"" in `JS Client and JVM Server` new project wizard template
+- [`KT-32319`](https://youtrack.jetbrains.com/issue/KT-32319) Gradle, js, webpack: source-map-loader failed to load source contents from relative urls
+- [`KT-33417`](https://youtrack.jetbrains.com/issue/KT-33417) NodeTest failed with error "Failed to create MD5 hash" after NodeRun is executed
+- [`KT-33747`](https://youtrack.jetbrains.com/issue/KT-33747) Exception doesn't fail the test in kotlin js node runner
+- [`KT-33828`](https://youtrack.jetbrains.com/issue/KT-33828) jsPackageJson task fails after changing artifact origin repository
+- [`KT-34460`](https://youtrack.jetbrains.com/issue/KT-34460) NPM packages clash if declared in dependencies and devDependencies both
+- [`KT-34555`](https://youtrack.jetbrains.com/issue/KT-34555) [Kotlin/JS] Unsafe webpack config merge
+
+### Tools. Gradle. Native
+
+- [`KT-33076`](https://youtrack.jetbrains.com/issue/KT-33076) MPP Gradle plugin: Produce final native binaries from compilation output instead of sources
+- [`KT-33645`](https://youtrack.jetbrains.com/issue/KT-33645) Kotlin/Native: Compilation failure if a library passed by the -Xinclude option contains a constructor annotated with @OverrideInit
+- [`KT-34259`](https://youtrack.jetbrains.com/issue/KT-34259) MPP Gradle plugin: Support fat frameworks for watchOS and tvOS
+- [`KT-34329`](https://youtrack.jetbrains.com/issue/KT-34329) Support watchOS and tvOS in CocoaPods Gradle plugin
+
+### Tools. J2K
+
+#### New Features
+
+- [`KT-7940`](https://youtrack.jetbrains.com/issue/KT-7940) J2K: convert Integer.MAX_VALUE to Int.MAX_VALUE
+- [`KT-22412`](https://youtrack.jetbrains.com/issue/KT-22412) J2K: Intention to replace if(...) throw IAE with require
+- [`KT-22680`](https://youtrack.jetbrains.com/issue/KT-22680) Request: when converting Java->Kotlin, try to avoid creating functions for constant fields (`static final`)
+
+#### Performance Improvements
+
+- [`KT-33725`](https://youtrack.jetbrains.com/issue/KT-33725) Java->Kotlin converter on paste performs expensive reparse in unrelated contexts
+- [`KT-33854`](https://youtrack.jetbrains.com/issue/KT-33854) J2K conversion of Interface freezes UI for more than 10 seconds without progress dialog
+- [`KT-33875`](https://youtrack.jetbrains.com/issue/KT-33875) [NewJ2K] InspectionLikeProcessingGroup pipeline rework: query isApplicable in parallel for all element first, apply relevant after in EDT
+
+#### Fixes
+
+- [`KT-19603`](https://youtrack.jetbrains.com/issue/KT-19603) A mutable container property updated from another class converts to red code
+- [`KT-19607`](https://youtrack.jetbrains.com/issue/KT-19607) Static member qualified by child class converted to red code
+- [`KT-20035`](https://youtrack.jetbrains.com/issue/KT-20035) Automatic conversion from Java 1.8 to Kotlin 1.1.4 using Idea 2017.2.2: null!!
+- [`KT-21504`](https://youtrack.jetbrains.com/issue/KT-21504) J2K: Convert Long.parseLong(s) to s.toLong()
+- [`KT-24293`](https://youtrack.jetbrains.com/issue/KT-24293) Bug: conversion of Java "List" into Kotlin doesn't produce "MutableList"
+- [`KT-32253`](https://youtrack.jetbrains.com/issue/KT-32253) Converting Java class with field initialized by constructor parameter used to initialize a different field or named as a different field produces red code
+- [`KT-32696`](https://youtrack.jetbrains.com/issue/KT-32696) New J2K: java List is wrongly converted when pasting it to Kotlin file
+- [`KT-32903`](https://youtrack.jetbrains.com/issue/KT-32903) J2K: Static import is converted to unresolved reference
+- [`KT-33235`](https://youtrack.jetbrains.com/issue/KT-33235) Remove "Replace guard clause with kotlin's function call" inspection and tranform it to J2K post-processing
+- [`KT-33434`](https://youtrack.jetbrains.com/issue/KT-33434) UninitializedPropertyAccessException occurs after J2K convertion of package with custom functional interface and it's usage
+- [`KT-33445`](https://youtrack.jetbrains.com/issue/KT-33445) Two definitions of org.jetbrains.kotlin.idea.j2k.J2kPostProcessing in Kotlin 1.3.50-rc
+- [`KT-33500`](https://youtrack.jetbrains.com/issue/KT-33500) Unresolved reference after J2K convertion of isNaN/isFinite
+- [`KT-33556`](https://youtrack.jetbrains.com/issue/KT-33556) J2K converter fails on statically imported global overloaded functions
+- [`KT-33679`](https://youtrack.jetbrains.com/issue/KT-33679) Result of assignment with operation differs in kotlin after J2K conversion
+- [`KT-33687`](https://youtrack.jetbrains.com/issue/KT-33687) Extra empty lines are added after comment after J2K conversion
+- [`KT-33743`](https://youtrack.jetbrains.com/issue/KT-33743) Reference to static field outside its class is unresolved after J2K conversion
+- [`KT-33756`](https://youtrack.jetbrains.com/issue/KT-33756) J2K: main method with varargs is converted to non-runnable main kotlin method
+- [`KT-33863`](https://youtrack.jetbrains.com/issue/KT-33863) java.lang.IllegalStateException: argument must not be null exception occurs on J2K conversion of Generic class usage without type parameter
+- [`KT-19355`](https://youtrack.jetbrains.com/issue/KT-19355) "Variable expected" error after J2K for increment/decrement of an object field
+- [`KT-19569`](https://youtrack.jetbrains.com/issue/KT-19569) Java wrappers for primitives are converted to nullable types with nullability errors in Kotlin
+- [`KT-30643`](https://youtrack.jetbrains.com/issue/KT-30643) J2K: wrong position of TYPE_USE annotation
+- [`KT-32518`](https://youtrack.jetbrains.com/issue/KT-32518) Nullability information is lost after J2K convertion of constructor with null parameter
+- [`KT-33941`](https://youtrack.jetbrains.com/issue/KT-33941) J2K: Overload resolution ambiguity with assertThat and `StackOverflowError` in IDEA
+- [`KT-33942`](https://youtrack.jetbrains.com/issue/KT-33942) New J2K: `StackOverflowError` from `org.jetbrains.kotlin.nj2k.inference.common.BoundTypeCalculatorImpl.boundTypeUnenhanced`
+- [`KT-34164`](https://youtrack.jetbrains.com/issue/KT-34164) J2K: on converting static method references in other .java sources are not corrected
+- [`KT-34165`](https://youtrack.jetbrains.com/issue/KT-34165) J2K: imports are lost in conversion, references resolve to different same-named classes
+- [`KT-34266`](https://youtrack.jetbrains.com/issue/KT-34266) Multiple errors after converting Java class implementing an interface from another file
+
+### Tools. JPS
+
+- [`KT-33808`](https://youtrack.jetbrains.com/issue/KT-33808) JPS compilation is not incremental in IDEA 2019.3
+
+### Tools. Maven
+
+- [`KT-34006`](https://youtrack.jetbrains.com/issue/KT-34006) Maven plugin do not consider .kts files as Kotlin sources
+- [`KT-34011`](https://youtrack.jetbrains.com/issue/KT-34011) Kotlin scripting plugin is not loaded by default from kotlin maven plugin
+
+### Tools. REPL
+
+- [`KT-27956`](https://youtrack.jetbrains.com/issue/KT-27956) REPL/Script: extract classes and names right from ClassLoader
+
+### Tools. Scripts
+
+- [`KT-31661`](https://youtrack.jetbrains.com/issue/KT-31661) ClassNotFoundException in runtime for 'kotlinc -script' while compilation is fine
+- [`KT-31704`](https://youtrack.jetbrains.com/issue/KT-31704) [kotlin-scripting] passing `name` to String.toScriptSource make script compilation failed
+- [`KT-32234`](https://youtrack.jetbrains.com/issue/KT-32234) "Unable to derive module descriptor" when using Kotlin compiler (embeddable) in Java 9+ modular builds
+- [`KT-33529`](https://youtrack.jetbrains.com/issue/KT-33529) NCDF running kotlin script from command line
+- [`KT-33554`](https://youtrack.jetbrains.com/issue/KT-33554) Classpath not passed properly when evaluating standard script with `kotlinc`
+- [`KT-33892`](https://youtrack.jetbrains.com/issue/KT-33892) REPL/Script: Implement mechanism for resolve top-level functions and properties from classloader
+- [`KT-34294`](https://youtrack.jetbrains.com/issue/KT-34294) SamWithReceiver cannot be used with new scripting API
+
+### Tools. kapt
+
+- [`KT-31291`](https://youtrack.jetbrains.com/issue/KT-31291) Incremental Kapt: IllegalArgumentException from `org.jetbrains.org.objectweb.asm.ClassVisitor.<init>`
+- [`KT-33028`](https://youtrack.jetbrains.com/issue/KT-33028) Kapt error "Unable to find package java.lang in classpath or bootclasspath" on JDK 11 with `-source 8`
+- [`KT-33050`](https://youtrack.jetbrains.com/issue/KT-33050) kapt does not honor source/target compatibility of enclosing project
+- [`KT-33052`](https://youtrack.jetbrains.com/issue/KT-33052) Kapt generates invalid java stubs for enum members with class bodies on JDK 11
+- [`KT-33056`](https://youtrack.jetbrains.com/issue/KT-33056) Incremental kapt is disabled due to `javaslang.match.PatternsProcessor` processor on classpath when Worker API is enabled
+- [`KT-33493`](https://youtrack.jetbrains.com/issue/KT-33493) 1.3.50, org.jetbrains.org.objectweb.asm.ClassVisitor.<init>
+- [`KT-33515`](https://youtrack.jetbrains.com/issue/KT-33515) Incremental kapt fails when I remove an annotated file
+- [`KT-33889`](https://youtrack.jetbrains.com/issue/KT-33889) Incremental KAPT: NoSuchMethodError: 'java.util.regex.Pattern com.sun.tools.javac.processing.JavacProcessingEnvironment.validImportStringToPattern(java.lang.String)'
+- [`KT-33503`](https://youtrack.jetbrains.com/issue/KT-33503) Kapt, Spring Boot: "Could not resolve all files for configuration ':_classStructurekaptKotlin'"
+- [`KT-33800`](https://youtrack.jetbrains.com/issue/KT-33800) KAPT aptMode=compile fails to compile certain legitimate code
+
+## 1.3.50
+
+### Compiler
+
+- [`KT-12787`](https://youtrack.jetbrains.com/issue/KT-12787) Debugger: Generate line number at end of function (to set a breakpoint on the last line of the block)
+- [`KT-23675`](https://youtrack.jetbrains.com/issue/KT-23675) "Parameter specified as non-null is null: method org.jetbrains.kotlin.codegen.FrameMapBase.getIndex, parameter descriptor" when classes are defined inside an anonymous extension function and access a field of the extension function's `this` instance
+- [`KT-24596`](https://youtrack.jetbrains.com/issue/KT-24596) Refactor / Inline const property does not insert its value into usage in annotation
+- [`KT-25497`](https://youtrack.jetbrains.com/issue/KT-25497) kotlinx.serialization - throws Backend Internal error exception during code generation of sealed classes
+- [`KT-28927`](https://youtrack.jetbrains.com/issue/KT-28927) "IllegalStateException: Arrays of class literals are not supported yet" in AnnotationDeserializer.resolveArrayElementType
+- [`KT-31070`](https://youtrack.jetbrains.com/issue/KT-31070) IndexOutOfBoundsException in Analyzer with @JvmOverloads constructor with 34+ parameters
+- [`KT-31265`](https://youtrack.jetbrains.com/issue/KT-31265) FIR: experimental compiler
+- [`KT-31535`](https://youtrack.jetbrains.com/issue/KT-31535) False positives from compiler warning IMPLICIT_NOTHING_AS_TYPE_PARAMETER
+- [`KT-31969`](https://youtrack.jetbrains.com/issue/KT-31969) NI: false positive USELESS_ELVIS with multiple elvis calls
+- [`KT-32044`](https://youtrack.jetbrains.com/issue/KT-32044) For loop over full UByte range terminates at UInt bound.
+- [`KT-25432`](https://youtrack.jetbrains.com/issue/KT-25432) No smartcast on qualifier expression of captured type
+- [`KT-30796`](https://youtrack.jetbrains.com/issue/KT-30796) psi2ir generates IrErrorType for elvis with generic type having nullable upper-bound when expected type is not nullable
+- [`KT-31242`](https://youtrack.jetbrains.com/issue/KT-31242) "Can't find enclosing method" proguard compilation exception with inline and crossinline
+- [`KT-31347`](https://youtrack.jetbrains.com/issue/KT-31347) "IndexOutOfBoundsException: Insufficient maximum stack size" with crossinline and suspend
+- [`KT-31367`](https://youtrack.jetbrains.com/issue/KT-31367) IllegalStateException: Concrete fake override public open fun (...)  defined in TheIssue[PropertyGetterDescriptorImpl@1a03c376] should have exactly one concrete super-declaration: []
+- [`KT-31734`](https://youtrack.jetbrains.com/issue/KT-31734) Empty parameter list required on Annotations of function types
+- [`KT-32434`](https://youtrack.jetbrains.com/issue/KT-32434) New type inference fails for Caffeine Cache
+- [`KT-32452`](https://youtrack.jetbrains.com/issue/KT-32452) Kotlin 1.3.40 - problem in IDE with new type inference and suspending method reference
+- [`KT-32407`](https://youtrack.jetbrains.com/issue/KT-32407) NI: "use property access syntax" intention causes freezes in editor
+- [`KT-33127`](https://youtrack.jetbrains.com/issue/KT-33127) Script result value is not calculated properly for the last expression
+- [`KT-33157`](https://youtrack.jetbrains.com/issue/KT-33157) Inline class with generic method is considered bad class by javac
+
+### Docs & Examples
+
+- [`KT-16602`](https://youtrack.jetbrains.com/issue/KT-16602) Provide examples of sorting API usage
+- [`KT-32353`](https://youtrack.jetbrains.com/issue/KT-32353) Document order of array elements initialization
+
+### IDE
+
+#### New Features
+
+- [`KT-28098`](https://youtrack.jetbrains.com/issue/KT-28098) Insert space after automatically closed right brace of nested lambda to follow code style
+
+#### Fixes
+
+- [`KT-16476`](https://youtrack.jetbrains.com/issue/KT-16476) Extend selection (Select Word) doesn't select just KDoc if cursor is just before the KDoc
+- [`KT-21374`](https://youtrack.jetbrains.com/issue/KT-21374) Imports optimized tooltip is displayed, even if no changes were made
+- [`KT-21422`](https://youtrack.jetbrains.com/issue/KT-21422) IDE can't import class from root package
+- [`KT-27344`](https://youtrack.jetbrains.com/issue/KT-27344) MPP: jvmWithJava: no IDE module dependency is created between Kotlin test and Java main on import; Gradle build is successful
+- [`KT-29667`](https://youtrack.jetbrains.com/issue/KT-29667) Kotlin update settings has wrong looking text boxes for versions
+- [`KT-30133`](https://youtrack.jetbrains.com/issue/KT-30133) Update copyright creates duplicates for build.gradle.kts files
+- [`KT-30782`](https://youtrack.jetbrains.com/issue/KT-30782) 'Show Method Separators' does not separate expression body Kotlin functions
+- [`KT-31022`](https://youtrack.jetbrains.com/issue/KT-31022) `Quick definition` does not show Kotlin code in Java files
+- [`KT-31499`](https://youtrack.jetbrains.com/issue/KT-31499) "Extend selection" selects escaped identifier name together with backticks
+- [`KT-31595`](https://youtrack.jetbrains.com/issue/KT-31595) "Complete current statement" for method call closes brace at wrong place
+- [`KT-31637`](https://youtrack.jetbrains.com/issue/KT-31637) NPE in IDE when organizing imports
+- [`KT-31786`](https://youtrack.jetbrains.com/issue/KT-31786) KNPE at copy attempt due to kdoc reference
+- [`KT-32276`](https://youtrack.jetbrains.com/issue/KT-32276) Fix flaky test for ultra light classes
+- [`KT-32364`](https://youtrack.jetbrains.com/issue/KT-32364) Remove deprecated usages of OUT_OF_CODE_BLOCK_MODIFICATION_COUNT and write a replacement for Kotlin language
+- [`KT-32370`](https://youtrack.jetbrains.com/issue/KT-32370) Lambdas should have implicit `return` in Kotlin Uast
+- [`KT-12096`](https://youtrack.jetbrains.com/issue/KT-12096) Spring: rename of Kotlin bean defined in `@Bean` annotation fails
+- [`KT-28193`](https://youtrack.jetbrains.com/issue/KT-28193) Exception: Mirror element should never be calculated for light classes generated from a single file
+- [`KT-28822`](https://youtrack.jetbrains.com/issue/KT-28822) Dependencies in Kotlin MPP project could be wrongly resolved if project was not build before import
+- [`KT-29267`](https://youtrack.jetbrains.com/issue/KT-29267) Enable ultra-light classes by default
+- [`KT-31129`](https://youtrack.jetbrains.com/issue/KT-31129) Call only Kotlin-specific reference contributors for getting Kotlin references from PSI
+- [`KT-32082`](https://youtrack.jetbrains.com/issue/KT-32082) Kotlin facet: 1.3.40 plugin does not properly read target platform settings of 1.3.50 plugin
+- [`KT-32969`](https://youtrack.jetbrains.com/issue/KT-32969) Data class extending abstract class with final `toString`, `equals` or `hashCode` causes exception
+- [`KT-33245`](https://youtrack.jetbrains.com/issue/KT-33245) IllegalArgumentException exception occurs on Tools->Configure Koltin in Project action in Android Studio
+
+### IDE. Completion
+
+- [`KT-9792`](https://youtrack.jetbrains.com/issue/KT-9792) Don't propose the same name for arguments of lambda on completion of function call with lambda template
+- [`KT-29572`](https://youtrack.jetbrains.com/issue/KT-29572) Smart completing anonymous object uses incorrect code style
+- [`KT-25264`](https://youtrack.jetbrains.com/issue/KT-25264) Freeze in Kotlin file on completion
+- [`KT-32519`](https://youtrack.jetbrains.com/issue/KT-32519) Keyword completion: support fixing layout and typo tolerance
+
+### IDE. Debugger
+
+#### New Features
+
+- [`KT-30740`](https://youtrack.jetbrains.com/issue/KT-30740) Display more information about variables when breakpoint is set inside lambda expression
+
+#### Fixes
+
+- [`KT-8579`](https://youtrack.jetbrains.com/issue/KT-8579) Debugger: Evaluate expression fails at typed arrays
+- [`KT-10183`](https://youtrack.jetbrains.com/issue/KT-10183) Debugger: receiver properties are not shown inline in extension function
+- [`KT-11663`](https://youtrack.jetbrains.com/issue/KT-11663) Assignment is not possible in Evaluate expression
+- [`KT-11706`](https://youtrack.jetbrains.com/issue/KT-11706) Attempts to evaluate java method calls on 'Array' instance in debugger fail with NoSuchMethodError
+- [`KT-11888`](https://youtrack.jetbrains.com/issue/KT-11888) Evaluate Expression for expression with synchronized
+- [`KT-11938`](https://youtrack.jetbrains.com/issue/KT-11938) Empty condition is marked as error
+- [`KT-13188`](https://youtrack.jetbrains.com/issue/KT-13188) Cannot evaluate expression with local extension function
+- [`KT-14421`](https://youtrack.jetbrains.com/issue/KT-14421) Debugger: breakpoint set on trivial if/while is not hit
+- [`KT-15259`](https://youtrack.jetbrains.com/issue/KT-15259) Debug: closing brace of object definition is considered executable; ISE: "Don't call this method for local declarations: OBJECT_DECLARATION" at LazyDeclarationResolver.getMemberScopeDeclaredIn()
+- [`KT-19084`](https://youtrack.jetbrains.com/issue/KT-19084) Breakpoints on Debugger altering Result
+- [`KT-19556`](https://youtrack.jetbrains.com/issue/KT-19556) Kotlin exception while debugging IJ plugin code
+- [`KT-19980`](https://youtrack.jetbrains.com/issue/KT-19980) Debug: evaluation fails for setter of member extention property
+- [`KT-20560`](https://youtrack.jetbrains.com/issue/KT-20560) Evaluate expression doesn't work for super method call
+- [`KT-23526`](https://youtrack.jetbrains.com/issue/KT-23526) In *.kts scripts, debugger ignores breakpoints in top-level statements and members
+- [`KT-24914`](https://youtrack.jetbrains.com/issue/KT-24914) AS: Uninitialized yet lazy properties called on first debug point reach
+- [`KT-26742`](https://youtrack.jetbrains.com/issue/KT-26742) Debugger can't evaluate expected top-level function from common code
+- [`KT-30120`](https://youtrack.jetbrains.com/issue/KT-30120) False positive "Unused equals expression" in evaluate expression window
+- [`KT-30730`](https://youtrack.jetbrains.com/issue/KT-30730) Missing tooltip for "Kotlin variables view" button
+- [`KT-30919`](https://youtrack.jetbrains.com/issue/KT-30919) Debugger's "Kotlin View" doesn't show variables inside lambdas
+- [`KT-30976`](https://youtrack.jetbrains.com/issue/KT-30976) Debugger: No access to receiver evaluating named parameters during call to extension function
+- [`KT-31418`](https://youtrack.jetbrains.com/issue/KT-31418) java.lang.ClassCastException : java.lang.annotation.Annotation[] cannot be cast to byte[]
+- [`KT-31510`](https://youtrack.jetbrains.com/issue/KT-31510) isDumb should be used only under read action: KotlinEvaluator
+- [`KT-31702`](https://youtrack.jetbrains.com/issue/KT-31702) Debugger can't stop on breakpoint on `Unit` expression from coroutine context
+- [`KT-31709`](https://youtrack.jetbrains.com/issue/KT-31709) Evaluate: "IllegalArgumentException: Parameter specified as non-null is null: method org.jetbrains.kotlin.codegen.FrameMapBase.getIndex, parameter descriptor" with nested lambda member access
+- [`KT-24829`](https://youtrack.jetbrains.com/issue/KT-24829) Access to coroutineContext in 'Evaluate expression'
+
+### IDE. Gradle
+
+- [`KT-19693`](https://youtrack.jetbrains.com/issue/KT-19693) Import package prefix from Gradle
+- [`KT-30667`](https://youtrack.jetbrains.com/issue/KT-30667) Dependencies of a module on a multiplatform one with a JVM target and `withJava()` configured, are incorrectly resolved in IDE
+- [`KT-32300`](https://youtrack.jetbrains.com/issue/KT-32300) Add possibility to distinguish kotlin source root from java source root
+- [`KT-31014`](https://youtrack.jetbrains.com/issue/KT-31014) Gradle, JS: Webpack watch mode
+- [`KT-31843`](https://youtrack.jetbrains.com/issue/KT-31843) Memory leak caused by KOTLIN_TARGET_DATA_NODE on project reimport
+
+### IDE. Gradle. Script
+
+- [`KT-31779`](https://youtrack.jetbrains.com/issue/KT-31779) "Highlighting in scripts is not available"
+- [`KT-30638`](https://youtrack.jetbrains.com/issue/KT-30638) "Highlighting in scripts is not available until all Script Dependencies are loaded" in Diff viewer
+- [`KT-30974`](https://youtrack.jetbrains.com/issue/KT-30974) Script dependencies resolution failed error while trying to use Kotlin for Gradle
+- [`KT-31440`](https://youtrack.jetbrains.com/issue/KT-31440) Add link to Gradle Kotlin DSL logs when script dependencies resolution process fails
+- [`KT-32483`](https://youtrack.jetbrains.com/issue/KT-32483) CNFE org.gradle.kotlin.dsl.KotlinBuildScript on creating new Gradle Kotlin project from wizard
+- [`KT-21501`](https://youtrack.jetbrains.com/issue/KT-21501) build.gradle.kts displays failures if not using java sdk for module
+
+### IDE. Inspections and Intentions
+
+#### New Features
+
+- [`KT-8958`](https://youtrack.jetbrains.com/issue/KT-8958) ReplaceWith intention message could be more helpful in case of generic substitution
+- [`KT-12515`](https://youtrack.jetbrains.com/issue/KT-12515) Quickfix "by Delegates.notNull()" as replacement for "lateinit" for primitive type
+- [`KT-14344`](https://youtrack.jetbrains.com/issue/KT-14344) Suggest to replace manual range with explicit `indices` call or iteration over collection
+- [`KT-17916`](https://youtrack.jetbrains.com/issue/KT-17916) Import popup does not indicate deprecated classes
+- [`KT-23501`](https://youtrack.jetbrains.com/issue/KT-23501) Add intention for converting ordinary properties to 'lazy' and vise versa
+- [`KT-25006`](https://youtrack.jetbrains.com/issue/KT-25006) Add inspection "'equals()' between objects of inconvertible primitive / enum / string types"
+- [`KT-27353`](https://youtrack.jetbrains.com/issue/KT-27353) Quickfix to add a constructor parameter from parent class to child class
+- [`KT-30124`](https://youtrack.jetbrains.com/issue/KT-30124) Add inspection to replace java.util.Arrays.equals with contentEquals
+- [`KT-30640`](https://youtrack.jetbrains.com/issue/KT-30640) Add inspection for check/require/checkNotNull/requireNotNull
+- [`KT-30775`](https://youtrack.jetbrains.com/issue/KT-30775) Inspection for the case when one lateinit var overrides another lateinit var
+- [`KT-31476`](https://youtrack.jetbrains.com/issue/KT-31476) Improve "Create expect..." quickfix
+- [`KT-31533`](https://youtrack.jetbrains.com/issue/KT-31533) Make "Add operator modifier" an inspection instead of intention
+- [`KT-31795`](https://youtrack.jetbrains.com/issue/KT-31795) Inspection: simplify property setter with custom visibility
+- [`KT-31924`](https://youtrack.jetbrains.com/issue/KT-31924) Make "add import" intention more flexible based on caret position
+- [`KT-30970`](https://youtrack.jetbrains.com/issue/KT-30970) No warning for empty `if` operator and `also`method
+
+#### Fixes
+
+- [`KT-12567`](https://youtrack.jetbrains.com/issue/KT-12567) "Introduce 'when' subject" intention does not work for "this" in extension function
+- [`KT-14369`](https://youtrack.jetbrains.com/issue/KT-14369) "Replace elvis expression with 'if" intention produces boilerplate code for 'return' in RHS
+- [`KT-16067`](https://youtrack.jetbrains.com/issue/KT-16067) "Replace 'if' expression with elvis expression" suggests replacing an idiomatic code with non-idiomatic
+- [`KT-19643`](https://youtrack.jetbrains.com/issue/KT-19643) Tune or disable the FoldInitializerAndIfToElvis inspection
+- [`KT-24439`](https://youtrack.jetbrains.com/issue/KT-24439) No method imports suggested
+- [`KT-25786`](https://youtrack.jetbrains.com/issue/KT-25786) False positive "Not-null extension receiver of inline function can be made nullable" with `operator fun invoke`
+- [`KT-25905`](https://youtrack.jetbrains.com/issue/KT-25905) False positive for 'LeakingThis' on a method call in enum class body
+- [`KT-27074`](https://youtrack.jetbrains.com/issue/KT-27074) False positive "Foldable if-then" with Result type
+- [`KT-27550`](https://youtrack.jetbrains.com/issue/KT-27550) "Redundant explicit this" false positive with subclass and extension lambda
+- [`KT-27563`](https://youtrack.jetbrains.com/issue/KT-27563) Generate toString in common code shouldn't use java.util.Arrays
+- [`KT-27822`](https://youtrack.jetbrains.com/issue/KT-27822) Don't suggest `might be const` on `actual` member declaration
+- [`KT-28595`](https://youtrack.jetbrains.com/issue/KT-28595) "Assignment should be lifted out of 'if'" false negative for different but compatible derived types
+- [`KT-29192`](https://youtrack.jetbrains.com/issue/KT-29192) "Convert property to function" with explicit generic type loses getter body
+- [`KT-29716`](https://youtrack.jetbrains.com/issue/KT-29716) With both explicit and implicit package prefixes "Package name does not match containing directory" inspection suggests not usable quick fix
+- [`KT-29731`](https://youtrack.jetbrains.com/issue/KT-29731) Don't suggest `Add val/var to parameter` at expect class constructor
+- [`KT-30191`](https://youtrack.jetbrains.com/issue/KT-30191) "Lift out of if" intention isn't suggested for assignment of null
+- [`KT-30197`](https://youtrack.jetbrains.com/issue/KT-30197) ReplaceWith for deprecated function adds class literal/callable reference argument above unless it is used in substitution
+- [`KT-30627`](https://youtrack.jetbrains.com/issue/KT-30627) "Use property access syntax" produces red code if setter argument is a lambda with implicit SAM conversion
+- [`KT-30804`](https://youtrack.jetbrains.com/issue/KT-30804) Property declaration goes to annotation comment when removing only modifier using RemoveModifierFix
+- [`KT-30975`](https://youtrack.jetbrains.com/issue/KT-30975) ''when' has only 'else' branch and should be simplified' inspection removes subject variable definition used in else branch
+- [`KT-31033`](https://youtrack.jetbrains.com/issue/KT-31033) "Create expect ..." quick fix incorrectly works for a secondary constructor in a multiplatform project
+- [`KT-31272`](https://youtrack.jetbrains.com/issue/KT-31272) Expand "create expected ..." quick fix highlighting also to a primary constructor
+- [`KT-31278`](https://youtrack.jetbrains.com/issue/KT-31278) Inappropriate "Remove redundant .let call" inspection
+- [`KT-31341`](https://youtrack.jetbrains.com/issue/KT-31341) Incorrect quickfix "Replace with Kotlin analog" for conversion to an extension, where the first argument is an expression with an operation
+- [`KT-31359`](https://youtrack.jetbrains.com/issue/KT-31359) "Invalid property key" inspection false positive for a bundle with several properties files
+- [`KT-31362`](https://youtrack.jetbrains.com/issue/KT-31362) 'Move variable declaration into `when`' quickfix comments left brace with EOL comment
+- [`KT-31443`](https://youtrack.jetbrains.com/issue/KT-31443) Remove braces intention places caret in a wrong place
+- [`KT-31446`](https://youtrack.jetbrains.com/issue/KT-31446) Incorrect quick fix “Create expected class" for inline class with parameter with actual
+- [`KT-31518`](https://youtrack.jetbrains.com/issue/KT-31518) Incorrect "Create expect function" for primary constructor
+- [`KT-31673`](https://youtrack.jetbrains.com/issue/KT-31673) Only `when` keyword should be highlighted in WhenWithOnlyElseInspection
+- [`KT-31716`](https://youtrack.jetbrains.com/issue/KT-31716) Decrease severity of PackageDirectoryMismatchInspection to INFO
+- [`KT-31717`](https://youtrack.jetbrains.com/issue/KT-31717) Decrease severity of RemoveCurlyBracesFromTemplateInspection
+- [`KT-31816`](https://youtrack.jetbrains.com/issue/KT-31816) "Package directive doesn't match file location" for root package is invisible in editor
+- [`KT-31954`](https://youtrack.jetbrains.com/issue/KT-31954) MoveVariableDeclarationIntoWhen should move the caret to the subject expression
+- [`KT-32001`](https://youtrack.jetbrains.com/issue/KT-32001) Wrong quickfixes for TOO_MANY_ARGUMENTS
+- [`KT-32010`](https://youtrack.jetbrains.com/issue/KT-32010) Convert ReplaceSingleLineLetIntention to inspections
+- [`KT-32046`](https://youtrack.jetbrains.com/issue/KT-32046) False negative "Redundant qualifier name" with class literal
+- [`KT-32112`](https://youtrack.jetbrains.com/issue/KT-32112) False positive "Redundant qualifier name"
+- [`KT-32318`](https://youtrack.jetbrains.com/issue/KT-32318) "Remove argument name" intention does not remove square braces for annotation vararg argument
+- [`KT-32320`](https://youtrack.jetbrains.com/issue/KT-32320) False negative "Redundant qualifier name" with local object
+- [`KT-32347`](https://youtrack.jetbrains.com/issue/KT-32347) Duplicative "Remove redundant 'public' modifier" suggestion for getter
+- [`KT-32365`](https://youtrack.jetbrains.com/issue/KT-32365) "Convert to sealed class" intention should not be suggested when no "class" keyword
+- [`KT-32419`](https://youtrack.jetbrains.com/issue/KT-32419) Spurious 'while' has empty body warning when body has explanatory comment
+- [`KT-32506`](https://youtrack.jetbrains.com/issue/KT-32506) False negative "Remove redundant qualifier name" with `java.util.ArrayList<Int>()`
+- [`KT-32454`](https://youtrack.jetbrains.com/issue/KT-32454) "Replace Java static method with Kotlin analog": invalid quick fix on 'abs()' function
+- [`KT-26242`](https://youtrack.jetbrains.com/issue/KT-26242) "Create test" intention does nothing in common module
+- [`KT-27208`](https://youtrack.jetbrains.com/issue/KT-27208) IDEA reports about the need to declare abstract or implement abstract method, but this method is @JvmStatic in an interface companion
+- [`KT-27555`](https://youtrack.jetbrains.com/issue/KT-27555) `Create actual ...` quick fix does nothing if the corresponding source set directory isn't created yet
+- [`KT-28121`](https://youtrack.jetbrains.com/issue/KT-28121) IDE: Warn on java files under "src/main/kotlin" or "src/test/kotlin" source roots
+- [`KT-28295`](https://youtrack.jetbrains.com/issue/KT-28295) Use `languageSettings` for a quick fix to enable experimental features in multiplatform projects
+- [`KT-28529`](https://youtrack.jetbrains.com/issue/KT-28529) Don't suggest `commonMain` source set as a target of `create expected ...` quick fix for a member of `*Test` source set
+- [`KT-28746`](https://youtrack.jetbrains.com/issue/KT-28746) “Create actual class” quick fix creates invalid file when is called from files located in package directory but don't have package name
+- [`KT-30622`](https://youtrack.jetbrains.com/issue/KT-30622) Add names to call arguments starting from given argument
+- [`KT-31404`](https://youtrack.jetbrains.com/issue/KT-31404) Redundant 'requireNotNull' or 'checkNotNull' inspection: don't remove first argument
+- [`KT-32705`](https://youtrack.jetbrains.com/issue/KT-32705) "Create expect" quick fix adds `actual` modifier to a `const`/`lateinit` declaration without a warning
+- [`KT-32967`](https://youtrack.jetbrains.com/issue/KT-32967) Warning about incorrectly placed Java source file isn't automatically dismissed on move of the file to the proper source root
+
+### IDE. JS
+
+- [`KT-31895`](https://youtrack.jetbrains.com/issue/KT-31895) New Project wizard: Kotlin Gradle + Kotlin/JS for Node.js: incorrect DSL is inserted
+
+### IDE. KDoc
+
+- [`KT-30985`](https://youtrack.jetbrains.com/issue/KT-30985) Missing line break in quick doc for enum constant
+
+### IDE. Multiplatform
+
+- [`KT-29757`](https://youtrack.jetbrains.com/issue/KT-29757) IDE fails to import transitive dependency of a JVM module to a multiplatform one
+
+### IDE. Navigation
+
+- [`KT-10215`](https://youtrack.jetbrains.com/issue/KT-10215) Kotlin classes are listed after Java classes in the navigation bar
+
+### IDE. Refactorings
+
+- [`KT-29720`](https://youtrack.jetbrains.com/issue/KT-29720) Refactor / Move does not update package statement with implicit prefix
+- [`KT-30762`](https://youtrack.jetbrains.com/issue/KT-30762) Inline method produces invalid code for suspend functions with receiver
+- [`KT-30748`](https://youtrack.jetbrains.com/issue/KT-30748) 100+ Seconds UI Freeze on performing a Move Refactoring on a file with a lot of usages (KotlinOptimizeImports in thread dump)
+
+### IDE. Scratch
+
+- [`KT-23604`](https://youtrack.jetbrains.com/issue/KT-23604) Scratch: end of line is wrongly indented with the end of scratch line output 
+- [`KT-27963`](https://youtrack.jetbrains.com/issue/KT-27963) Make REPL mode in Scratch files incremental
+- [`KT-29534`](https://youtrack.jetbrains.com/issue/KT-29534) Line output jumps to the next line together with cursor
+- [`KT-32791`](https://youtrack.jetbrains.com/issue/KT-32791) "Access is allowed from event dispatch thread only" while working with a scratch file
+
+### IDE. Script
+
+- [`KT-25187`](https://youtrack.jetbrains.com/issue/KT-25187) Kotlin script in src: warning: classpath entry points to a non-existent location on JDK 9+
+- [`KT-31152`](https://youtrack.jetbrains.com/issue/KT-31152) Errors in IDE when different Java Sdk are set as Project SDK and as Gradle JVM
+- [`KT-31521`](https://youtrack.jetbrains.com/issue/KT-31521) CNFE „org.jetbrains.kotlin.idea.caches.project.ScriptBinariesScopeCache“ on creating new Gradle based project
+- [`KT-31826`](https://youtrack.jetbrains.com/issue/KT-31826) Gradle clean task causes IDEA to lose kotlin scripting configuration
+- [`KT-31837`](https://youtrack.jetbrains.com/issue/KT-31837) TargetPlatform for scripts should depends on scriptDefinition.additionalArguments
+- [`KT-30690`](https://youtrack.jetbrains.com/issue/KT-30690) Highlighting for scripts in diff view doesn't work for left part
+- [`KT-32061`](https://youtrack.jetbrains.com/issue/KT-32061) Check classpath jars before applying script compilation result from file attributes
+- [`KT-32554`](https://youtrack.jetbrains.com/issue/KT-32554) Freezes in ScriptDependenciesUpdater
+
+### IDE. Tests Support
+
+- [`KT-30814`](https://youtrack.jetbrains.com/issue/KT-30814) MPP, 191 platform: with Gradle test runner run configuration for platform test is created without tasks
+
+### IDE. Wizards
+
+- [`KT-32105`](https://youtrack.jetbrains.com/issue/KT-32105) MPP project wizard: add option for Kotlin Gradle DSL
+
+### JS. Tools
+
+- [`KT-31527`](https://youtrack.jetbrains.com/issue/KT-31527) Keep generating empty `jsTest` task
+- [`KT-31565`](https://youtrack.jetbrains.com/issue/KT-31565) Gradle/JS: `npmResolve` is never UP-TO-DATE
+- [`KT-32326`](https://youtrack.jetbrains.com/issue/KT-32326) Gradle, test runner: support postponing test running error reporting at the end of the build
+- [`KT-32393`](https://youtrack.jetbrains.com/issue/KT-32393) Gradle, JS: Resolve projects lazily
+- [`KT-31560`](https://youtrack.jetbrains.com/issue/KT-31560) Gradle: provide descriptions for JS tasks
+- [`KT-31563`](https://youtrack.jetbrains.com/issue/KT-31563) Gradle/JS: npmResolve fails with "Invalid version" when user project's version does not match npm rules
+- [`KT-31566`](https://youtrack.jetbrains.com/issue/KT-31566) Gradle/JS: with explicit call to `nodejs { testTask { useNodeJs() } }` configuration fails : "Could not find which method to invoke"
+- [`KT-31694`](https://youtrack.jetbrains.com/issue/KT-31694) Gradle, NPM, windows: creating symlink requires administrator privilege
+
+### Libraries
+
+- [`KT-29372`](https://youtrack.jetbrains.com/issue/KT-29372) measureTime that returns both the result of block and elapsed time
+- [`KT-32083`](https://youtrack.jetbrains.com/issue/KT-32083) Incorrect ReplaceWith annotation on kotlin.js.pow
+- [`KT-12749`](https://youtrack.jetbrains.com/issue/KT-12749) Provide Int.bitCount, Long.bitCount etc.
+- [`KT-32359`](https://youtrack.jetbrains.com/issue/KT-32359) Common Array.fill
+- [`KT-33225`](https://youtrack.jetbrains.com/issue/KT-33225) JS: Incorrect conversion of infinite Double to Long
+
+### Reflection
+
+- [`KT-22923`](https://youtrack.jetbrains.com/issue/KT-22923) Reflection getMemberProperties fails: kotlin.reflect.jvm.internal.KotlinReflectionInternalError
+- [`KT-31318`](https://youtrack.jetbrains.com/issue/KT-31318) "KotlinReflectionInternalError: Method is not supported" on accessing array class annotation parameter
+
+### Tools. Daemon
+
+- [`KT-31550`](https://youtrack.jetbrains.com/issue/KT-31550) NSME org.jetbrains.kotlin.com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem.clearHandlersCache()V on compileKotlin task with plugin from master
+- [`KT-32490`](https://youtrack.jetbrains.com/issue/KT-32490) Compiler daemon tests fail on windows due to directory name being too long
+- [`KT-32950`](https://youtrack.jetbrains.com/issue/KT-32950) Daemon should inherit "-XX:MaxMetaspaceSize" of client VM
+- [`KT-32992`](https://youtrack.jetbrains.com/issue/KT-32992) Enable assertions in Kotlin Compile Daemon
+- [`KT-33027`](https://youtrack.jetbrains.com/issue/KT-33027) Compilation with daemon fails, because IncrementalModuleInfo#serialVersionUID does not match
+
+### Tools. CLI
+
+- [`KT-33177`](https://youtrack.jetbrains.com/issue/KT-33177) Introduce compiler flags -Xinline-classes and -Xpolymorphic-signature as a higher priority than -XXLanguage
+
+### Tools. Compiler Plugins
+
+- [`KT-28824`](https://youtrack.jetbrains.com/issue/KT-28824) Add jvm-abi-gen-embeddable for use with embeddable compiler
+- [`KT-31279`](https://youtrack.jetbrains.com/issue/KT-31279) JPS build with compiler plugin and "Keep compiler alive = No" fails with CCE: "Cannot cast NoArgComponentRegistrar to ComponentRegistrar" at ServiceLoaderLite.loadImplementations()
+- [`KT-32346`](https://youtrack.jetbrains.com/issue/KT-32346) kotlinx.serialization: Performance problems with completion/intellisense
+
+### Tools. Gradle
+
+#### New Features
+
+- [`KT-26655`](https://youtrack.jetbrains.com/issue/KT-26655) Precise metadata publishing and consumption for new MPP
+- [`KT-31018`](https://youtrack.jetbrains.com/issue/KT-31018) Gradle, JS: yarn
+- [`KT-31703`](https://youtrack.jetbrains.com/issue/KT-31703) Gradle, JS: automatically download d.ts and generate kotlin/js external declarations using dukat
+- [`KT-31890`](https://youtrack.jetbrains.com/issue/KT-31890) Gradle, JS, webpack: provide property with full bundle file path
+- [`KT-32015`](https://youtrack.jetbrains.com/issue/KT-32015) Gradle, JS: resolve configuration only while executing tasks of specific projects
+- [`KT-32136`](https://youtrack.jetbrains.com/issue/KT-32136) Gradle, test runner: handle case when test runtime exits abnormally
+- [`KT-26256`](https://youtrack.jetbrains.com/issue/KT-26256) In new MPP, support Java compilation in JVM targets
+- [`KT-30573`](https://youtrack.jetbrains.com/issue/KT-30573) Gradle, JS: enable source maps by default, change paths relative to node_modules directory
+- [`KT-30747`](https://youtrack.jetbrains.com/issue/KT-30747) Gradle, JS tests: provide option to disable test configuration per target
+- [`KT-31010`](https://youtrack.jetbrains.com/issue/KT-31010) Gradle, JS tests: Mocha
+- [`KT-31011`](https://youtrack.jetbrains.com/issue/KT-31011) Gradle, JS tests: Karma
+- [`KT-31013`](https://youtrack.jetbrains.com/issue/KT-31013) Gradle, JS: Webpack
+- [`KT-31016`](https://youtrack.jetbrains.com/issue/KT-31016) Gradle: yarn downloading
+- [`KT-31017`](https://youtrack.jetbrains.com/issue/KT-31017) Gradle, yarn: support workspaces
+- [`KT-31697`](https://youtrack.jetbrains.com/issue/KT-31697) Gradle, NPM: report about clashes in packages_imported
+
+#### Performance Improvements
+
+- [`KT-29538`](https://youtrack.jetbrains.com/issue/KT-29538) AndroidSubPlugin#getCommonResDirectories is very slow
+
+#### Fixes
+
+- [`KT-29343`](https://youtrack.jetbrains.com/issue/KT-29343) Kotlin MPP source set dependencies are not properly propagated to tests in Android projects
+- [`KT-30691`](https://youtrack.jetbrains.com/issue/KT-30691) Gradle, JS tests: Parent operation with id 947 not available when all tests passed
+- [`KT-31917`](https://youtrack.jetbrains.com/issue/KT-31917) Gradle, JS: transitive dependency between compilations in same project doesn't work
+- [`KT-31985`](https://youtrack.jetbrains.com/issue/KT-31985) Gradle, JS: webpack not working on windows
+- [`KT-32072`](https://youtrack.jetbrains.com/issue/KT-32072) Gradle, JS: browser() in DSL triggers project.evaluate()
+- [`KT-32204`](https://youtrack.jetbrains.com/issue/KT-32204) In an MPP, a dependency that is added to a non-root source set is incorrectly analyzed for source sets visibility
+- [`KT-32225`](https://youtrack.jetbrains.com/issue/KT-32225) In an MPP, if a dependency is added to a source set that does not take part in published compilations, it is not correctly analyzed in source set visibility inference
+- [`KT-32564`](https://youtrack.jetbrains.com/issue/KT-32564) Provide a flag to enable/disable hierarchical multiplatform mechanism in Gradle
+- [`KT-31023`](https://youtrack.jetbrains.com/issue/KT-31023) Update Gradle module metadata warning in MPP publishing
+- [`KT-31696`](https://youtrack.jetbrains.com/issue/KT-31696) Gradle, NPM: select one version between tools and all of compile configurations
+- [`KT-31891`](https://youtrack.jetbrains.com/issue/KT-31891) Gradle: JS or Native tests execution: `build --scan` fails with ISE "Expected attachment of type ... but did not find it"
+- [`KT-32210`](https://youtrack.jetbrains.com/issue/KT-32210) Kapt randomly fails with java.io.UTFDataFormatException
+- [`KT-32706`](https://youtrack.jetbrains.com/issue/KT-32706) Gradle target "jsBrowserWebpack" should use output of JS compile task as input
+- [`KT-32697`](https://youtrack.jetbrains.com/issue/KT-32697) [Tests] org.jetbrains.kotlin.gradle.SubpluginsIT
+- [`KT-33246`](https://youtrack.jetbrains.com/issue/KT-33246) Kotlin JS & Native tests + Gradle 5.6: No value has been specified for property 'binaryResultsDirectory'
+
+
+### Tools. Incremental Compile
+
+- [`KT-31310`](https://youtrack.jetbrains.com/issue/KT-31310) Incremental build of Kotlin/JS project fails with KNPE at IncrementalJsCache.nonDirtyPackageParts()
+
+### Tools. J2K
+
+#### New Features
+
+- [`KT-30776`](https://youtrack.jetbrains.com/issue/KT-30776) New J2K
+- [`KT-31836`](https://youtrack.jetbrains.com/issue/KT-31836) Suggest user to configure Kotlin in the project  when running new J2K file conversion
+- [`KT-32512`](https://youtrack.jetbrains.com/issue/KT-32512) ReplaceJavaStaticMethodWithKotlinAnalogInspection: add more cases for java.util.Arrays
+
+#### Fixes
+
+- [`KT-15791`](https://youtrack.jetbrains.com/issue/KT-15791) J2K converts class literals including redundant generic <*>
+- [`KT-31234`](https://youtrack.jetbrains.com/issue/KT-31234) New J2K: Exception occurs on converting Java class to Kotlin
+- [`KT-31250`](https://youtrack.jetbrains.com/issue/KT-31250) J2K: caret position of original file is preserved, adding spaces to resulting file
+- [`KT-31251`](https://youtrack.jetbrains.com/issue/KT-31251) J2K: Java class with members is converted to Kotlin class with `final` constructor
+- [`KT-31252`](https://youtrack.jetbrains.com/issue/KT-31252) J2K: resulted file is not formatted
+- [`KT-31254`](https://youtrack.jetbrains.com/issue/KT-31254) J2K: resulted source uses full qualified references instead of imports
+- [`KT-31255`](https://youtrack.jetbrains.com/issue/KT-31255) J2K: redundant modifiers in resulted source
+- [`KT-31726`](https://youtrack.jetbrains.com/issue/KT-31726) New J2K converts annotation with array parameter to single value parameter
+- [`KT-31809`](https://youtrack.jetbrains.com/issue/KT-31809) "Attempt to modify PSI for non-committed Document!" exception and broken kotlin file after new J2K conversion
+- [`KT-31821`](https://youtrack.jetbrains.com/issue/KT-31821) J2K: IDEA Ultimate: local variable: CCE: "PsiLocalVariableImpl cannot be cast to class JvmAnnotatedElement" at JavaToJKTreeBuilder$DeclarationMapper.toJK()
+- [`KT-32436`](https://youtrack.jetbrains.com/issue/KT-32436) NewJ2K generic field is not initialized after convertion
+- [`KT-19327`](https://youtrack.jetbrains.com/issue/KT-19327) Java to Kotlin converter fails to convert code using Java 8 Stream API
+- [`KT-21467`](https://youtrack.jetbrains.com/issue/KT-21467) Convert To Kotlin fails when using chained stream.flatmap methods
+- [`KT-24677`](https://youtrack.jetbrains.com/issue/KT-24677) j2k creates nullable type for child function but keeps not null type for parent function
+- [`KT-32572`](https://youtrack.jetbrains.com/issue/KT-32572) New J2K: Map with complex type as parameter is wrongly converted
+- [`KT-32602`](https://youtrack.jetbrains.com/issue/KT-32602) J2K: no conversion of `String.length()` method call to property access of existing String property
+- [`KT-32604`](https://youtrack.jetbrains.com/issue/KT-32604) kotlin.NotImplementedError exception occurs on converting Java call of toString method of data class to Kotlin
+- [`KT-32609`](https://youtrack.jetbrains.com/issue/KT-32609) New J2K: Comparable class is wrongly converted to Kotlin if parameter of compareTo marked with @NotNull annotation
+- [`KT-32693`](https://youtrack.jetbrains.com/issue/KT-32693) New J2K is throwing „Read access is allowed from event dispatch thread or inside read-action only“ on converting Java code inside Evaluate Expression window
+- [`KT-32702`](https://youtrack.jetbrains.com/issue/KT-32702) New J2K: lambda with method reference is converted to lamdba with excessive parameter declaration
+- [`KT-32835`](https://youtrack.jetbrains.com/issue/KT-32835) New J2K: NumberFormatException occurs on converting binary literals
+- [`KT-32837`](https://youtrack.jetbrains.com/issue/KT-32837) J2K: NumberFormatException occurs on converting literals with underscore characters
+- [`KT-22412`](https://youtrack.jetbrains.com/issue/KT-22412) J2K: Intention to replace if(...) throw IAE with require
+- [`KT-33371`](https://youtrack.jetbrains.com/issue/KT-33371) Add an ability to switch between old and new J2K via settings window
+- [`KT-32863`](https://youtrack.jetbrains.com/issue/KT-32863) New J2K: IllegalArgumentException occurs on Kotlin configuration in java project in Android Studio
+
+### Tools. JPS
+
+- [`KT-27181`](https://youtrack.jetbrains.com/issue/KT-27181) Compiler arguments are listed twice on JPS build of Gradle-based project
+- [`KT-13563`](https://youtrack.jetbrains.com/issue/KT-13563) Kotlin jps-plugin should allow to instrument bytecode from Intellij IDEA.
+
+### Tools. REPL
+
+- [`KT-15125`](https://youtrack.jetbrains.com/issue/KT-15125) Support JSR 223 bindings directly via script variables
+- [`KT-32085`](https://youtrack.jetbrains.com/issue/KT-32085) Kotlinc REPL: "java.lang.NoClassDefFoundError: org/jline/reader/LineReaderBuilder"
+
+### Tools. Scripts
+
+- [`KT-28137`](https://youtrack.jetbrains.com/issue/KT-28137) Implement result/return value for the regular (non-REPL) scripts
+
+### Tools. kapt
+
+- [`KT-30578`](https://youtrack.jetbrains.com/issue/KT-30578) `build/generated/source/kaptKotlin` is added as source directory to `main` instead of `jvmMain` when jvm { withJava() } is configured in a multiplatform project
+- [`KT-30739`](https://youtrack.jetbrains.com/issue/KT-30739) Kapt generated sources are not visible from the IDE when "Create separate module per source set" is disabled
+- [`KT-31127`](https://youtrack.jetbrains.com/issue/KT-31127) Kotlin-generating processor which uses Filer API breaks JavaCompile task
+- [`KT-31378`](https://youtrack.jetbrains.com/issue/KT-31378) v1.3.31: NoSuchElementException in kapt when kapt.incremental.apt=true
+- [`KT-32535`](https://youtrack.jetbrains.com/issue/KT-32535) Kapt aptMode=compile don't include files generated at `kapt.kotlin.generated` as sources to compile
+- [`KT-31471`](https://youtrack.jetbrains.com/issue/KT-31471) KAPT prints "IncrementalProcessor" instead of processor name in verbose mode
+
 ## 1.3.41
 
 ### Compiler

ReadMe.md

@@ -98,13 +98,13 @@ Development for some particular platform is possible after 'switching' that can
 ```sh
 cd kotlin-project-dir
 
-# switching to IntelliJ Idea 2018.2
-bunch switch . 182
+# switching to IntelliJ Idea 2019.1
+bunch switch 191
 ```
 
 ## <a name="working-in-idea"></a> Working with the project in IntelliJ IDEA
 
-Working with the Kotlin project requires at least IntelliJ IDEA 2017.3. You can download IntelliJ IDEA 2017.3 [here](https://www.jetbrains.com/idea/download).
+Working with the Kotlin project requires at least IntelliJ IDEA 2019.1. You can download IntelliJ IDEA 2019.1 [here](https://www.jetbrains.com/idea/download).
 
 After cloning the project, to import the project in Intellij choose the project directory in the 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.
@@ -113,7 +113,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` and choose `Gradle Test Runner` in the Gradle runner settings after importing the project.
 
-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".
+At this time, you can use the latest released 1.3.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
 

benchmarks/build.gradle.kts

@@ -0,0 +1,82 @@
+import kotlinx.benchmark.gradle.benchmark
+
+val benchmarks_version = "0.2.0-dev-7"
+buildscript {
+    val benchmarks_version = "0.2.0-dev-7"
+
+    repositories {
+        val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
+        if (cacheRedirectorEnabled) {
+            maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
+            maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
+        } else {
+            maven("https://dl.bintray.com/kotlin/kotlinx")
+            maven("https://dl.bintray.com/kotlin/kotlin-dev")
+        }
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlinx:kotlinx.benchmark.gradle:$benchmarks_version")
+    }
+}
+
+apply(plugin = "kotlinx.benchmark")
+
+plugins {
+    java
+    kotlin("jvm")
+}
+
+repositories {
+    val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
+    if (cacheRedirectorEnabled) {
+        maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
+        maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
+    } else {
+        maven("https://dl.bintray.com/kotlin/kotlinx")
+        maven("https://dl.bintray.com/kotlin/kotlin-dev")
+    }
+}
+
+dependencies {
+    compile(kotlinStdlib())
+    compile(project(":compiler:frontend"))
+    compile(project(":compiler:cli"))
+    compile(intellijCoreDep()) { includeJars("intellij-core") }
+    compile(jpsStandalone()) { includeJars("jps-model") }
+    Platform[192].orHigher {
+        compile(intellijPluginDep("java"))
+    }
+    compile(intellijDep()) { includeIntellijCoreJarDependencies(project) }
+    compile("org.jetbrains.kotlinx:kotlinx.benchmark.runtime-jvm:$benchmarks_version")
+}
+
+sourceSets {
+    "main" { projectDefault() }
+}
+
+benchmark {
+    configurations {
+        named("main") {
+            warmups = 10
+            iterations = 10
+            iterationTime = 1
+            iterationTimeUnit = "sec"
+            param("size", 1000)
+        }
+
+        register("fir") {
+            warmups = 10
+            iterations = 10
+            iterationTime = 1
+            iterationTimeUnit = "sec"
+            param("isIR", true)
+            param("size", 1000)
+
+            include("CommonCallsBenchmark")
+            //include("InferenceBaselineCallsBenchmark")
+        }
+    }
+    targets {
+        register("main")
+    }
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractInferenceBenchmark.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.Param
+import org.openjdk.jmh.annotations.Scope
+import org.openjdk.jmh.annotations.State
+
+@State(Scope.Benchmark)
+abstract class AbstractInferenceBenchmark : AbstractSimpleFileBenchmark() {
+    @Param("true", "false")
+    private var useNI: Boolean = false
+
+    override val useNewInference: Boolean
+        get() = useNI
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -0,0 +1,214 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.benchmarks
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.CharsetToolkit
+import com.intellij.psi.PsiElementFinder
+import com.intellij.psi.PsiFileFactory
+import com.intellij.psi.impl.PsiFileFactoryImpl
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.testFramework.LightVirtualFile
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
+import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.jvm.compiler.*
+import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
+import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.context.SimpleGlobalContext
+import org.jetbrains.kotlin.context.withModule
+import org.jetbrains.kotlin.context.withProject
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.builder.RawFirBuilder
+import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
+import org.jetbrains.kotlin.fir.java.FirLibrarySession
+import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.idea.KotlinLanguage
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
+import org.jetbrains.kotlin.storage.ExceptionTracker
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.io.File
+
+private fun createFile(shortName: String, text: String, project: Project): KtFile {
+    val virtualFile = object : LightVirtualFile(shortName, KotlinLanguage.INSTANCE, text) {
+        override fun getPath(): String {
+            //TODO: patch LightVirtualFile
+            return "/" + name
+        }
+    }
+
+    virtualFile.charset = CharsetToolkit.UTF8_CHARSET
+    val factory = PsiFileFactory.getInstance(project) as PsiFileFactoryImpl
+
+    return factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as KtFile
+}
+
+private val JDK_PATH = File("${System.getProperty("java.home")!!}/lib/rt.jar")
+private val RUNTIME_JAR = File(System.getProperty("kotlin.runtime.path") ?: "dist/kotlinc/lib/kotlin-runtime.jar")
+
+private val LANGUAGE_FEATURE_SETTINGS =
+        LanguageVersionSettingsImpl(
+                LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
+                specificFeatures = mapOf(LanguageFeature.NewInference to LanguageFeature.State.ENABLED)
+        )
+
+private fun newConfiguration(useNewInference: Boolean): CompilerConfiguration {
+    val configuration = CompilerConfiguration()
+    configuration.put(CommonConfigurationKeys.MODULE_NAME, "benchmark")
+    configuration.put(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, "../idea/resources")
+    configuration.addJvmClasspathRoot(JDK_PATH)
+    configuration.addJvmClasspathRoot(RUNTIME_JAR)
+    configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
+
+    val newInferenceState = if (useNewInference) LanguageFeature.State.ENABLED else LanguageFeature.State.DISABLED
+    configuration.languageVersionSettings = LanguageVersionSettingsImpl(
+            LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3,
+            specificFeatures = mapOf(
+                    LanguageFeature.NewInference to newInferenceState
+            )
+    )
+    return configuration
+}
+
+@State(Scope.Benchmark)
+abstract class AbstractSimpleFileBenchmark {
+
+    private var myDisposable: Disposable = Disposable { }
+    private lateinit var env: KotlinCoreEnvironment
+    private lateinit var file: KtFile
+
+    @Param("true", "false")
+    protected var isIR: Boolean = false
+
+    protected open val useNewInference get() = isIR
+
+    @Setup(Level.Trial)
+    fun setUp() {
+        if (isIR && !useNewInference) error("Invalid configuration")
+        env = KotlinCoreEnvironment.createForTests(
+                myDisposable, 
+                newConfiguration(useNewInference),
+                EnvironmentConfigFiles.JVM_CONFIG_FILES
+        )
+
+        if (isIR) {
+            Extensions.getArea(env.project)
+                    .getExtensionPoint(PsiElementFinder.EP_NAME)
+                    .unregisterExtension(JavaElementFinder::class.java)
+        }
+
+        file = createFile(
+                "test.kt",
+                buildText(),
+                env.project
+        )
+    }
+
+    protected fun analyzeGreenFile(bh: Blackhole) {
+        if (isIR) {
+            analyzeGreenFileIr(bh)
+        } else {
+            analyzeGreenFileFrontend(bh)
+        }
+    }
+
+    private fun analyzeGreenFileFrontend(bh: Blackhole) {
+        val tracker = ExceptionTracker()
+        val storageManager: StorageManager =
+                LockBasedStorageManager.createWithExceptionHandling("benchmarks", tracker)
+
+        val context = SimpleGlobalContext(storageManager, tracker)
+        val module =
+                ModuleDescriptorImpl(
+                        Name.special("<benchmark>"), storageManager,
+                        JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_DEPENDENCIES)
+                )
+        val moduleContext = context.withProject(env.project).withModule(module)
+
+        val result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
+                moduleContext.project,
+                listOf(file),
+                NoScopeRecordCliBindingTrace(),
+                env.configuration,
+                { scope -> JvmPackagePartProvider(LANGUAGE_FEATURE_SETTINGS, scope) }
+        )
+
+        assert(result.bindingContext.diagnostics.none { it.severity == Severity.ERROR })
+
+        bh.consume(result.shouldGenerateCode)
+    }
+
+    private fun analyzeGreenFileIr(bh: Blackhole) {
+        val scope = GlobalSearchScope.filesScope(env.project, listOf(file.virtualFile))
+                .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
+        val session = createSession(env, scope)
+        val firProvider = session.firProvider as FirProviderImpl
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
+
+        val totalTransformer = FirTotalResolveTransformer()
+        val firFile = builder.buildFirFile(file).also(firProvider::recordFile)
+
+        for (transformer in totalTransformer.transformers) {
+            transformer.transformFile(firFile, null)
+        }
+
+        bh.consume(firFile.hashCode())
+    }
+
+    protected abstract fun buildText(): String
+}
+
+fun createSession(
+        environment: KotlinCoreEnvironment,
+        sourceScope: GlobalSearchScope,
+        librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope)
+): FirSession {
+    val moduleInfo = FirTestModuleInfo()
+    val project = environment.project
+    val provider = FirProjectSessionProvider(project)
+    return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also {
+        createSessionForDependencies(provider, moduleInfo, librariesScope, environment)
+    }
+}
+
+private fun createSessionForDependencies(
+        provider: FirProjectSessionProvider,
+        moduleInfo: FirTestModuleInfo,
+        librariesScope: GlobalSearchScope,
+        environment: KotlinCoreEnvironment
+) {
+    val dependenciesInfo = FirTestModuleInfo()
+    moduleInfo.dependencies.add(dependenciesInfo)
+    FirLibrarySession.create(
+            dependenciesInfo, provider, librariesScope, environment.project,
+            environment.createPackagePartProvider(librariesScope)
+    )
+}
+
+class FirTestModuleInfo(
+        override val name: Name = Name.identifier("TestModule"),
+        val dependencies: MutableList<ModuleInfo> = mutableListOf(),
+        override val platform: TargetPlatform = JvmPlatforms.unspecifiedJvmPlatform,
+        override val analyzerServices: PlatformDependentAnalyzerServices = JvmPlatformAnalyzerServices
+) : ModuleInfo {
+    override fun dependencies(): List<ModuleInfo> = dependencies
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/CommonCallsBenchmark.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class CommonCallsBenchmark : AbstractSimpleFileBenchmark(){
+
+    @Param("1", "10", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun foo(): Int = 1
+            |
+            |fun bar() {
+            |${(1..size).joinToString("\n") { "    foo()" }}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/ComplexDataFlowBenchmark.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class ComplexDataFlowBenchmark : AbstractSimpleFileBenchmark(){
+
+    @Param("1", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |
+            |fun bar(x: Any?) {
+            |   var y = x
+            |${(1..size).joinToString("\n") {
+                """
+                |if (x is String) {
+                |   y = x
+                |}
+                |y = 1
+                """.trimMargin()
+            }}
+            |}
+            """.trimMargin()
+
+}
+

benchmarks/src/org/jetbrains/kotlin/benchmarks/ControlFlowOperators.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class ControlFlowOperators : AbstractSimpleFileBenchmark(){
+
+    @Param("1", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |var isTrue = true
+            |var s = ""
+            |fun bar() {
+            |${(1..size).joinToString("\n") {
+                """
+                |var x$it: String
+                |
+                |when (s) {
+                |   "A" -> { x$it = "1" }
+                |   "B" -> { x$it = "2" }
+                |   else -> { x$it = "3" }
+                |}
+                |
+                |while (isTrue) {
+                |   x$it.hashCode()
+                |}
+                """.trimMargin()
+            }}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/InferenceBaselineCallsBenchmark.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class InferenceBaselineCallsBenchmark : AbstractSimpleFileBenchmark() {
+
+    @Param("1", "10", "100", "1000", "5000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun foo(x: Int): Int = 1
+            |fun expectsInt(x: Int) {}
+            |fun bar(v: Int) {
+            |${(1..size).map { "    expectsInt(foo(v))" }.joinToString("\n")}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/InferenceExplicitArgumentsCallsBenchmark.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class InferenceExplicitArgumentsCallsBenchmark : AbstractInferenceBenchmark() {
+
+    @Param("1", "10", "100", "1000", "5000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun <T> foo(x: T): Int = 1
+            |fun expectsInt(x: Int) {}
+            |fun bar(v: Int) {
+            |${(1..size).map { "    expectsInt(foo<Int>(v))" }.joinToString("\n")}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/InferenceForInApplicableCandidate.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class InferenceForInApplicableCandidate : AbstractInferenceBenchmark() {
+
+    @Param("1", "10", "100", "1000", "5000", "10000")
+    private var size: Int = 1
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun <T : Comparable<T>> foo(x: MutableList<T>) {}
+            |fun <T> foo(x: MutableList<T>, y: (T, T) -> Int) {}
+            |fun bar(x: MutableList<Any>) {
+            |${(1..size).joinToString("\n") { "    foo(x) { a, b -> 1 }" }}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/InferenceFromArgumentCallsBenchmark.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class InferenceFromArgumentCallsBenchmark : AbstractInferenceBenchmark() {
+
+    @Param("1", "10", "100", "1000", "5000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun <T> foo(x: T): Int = 1
+            |fun expectsInt(x: Int) {}
+            |fun bar(v: Int) {
+            |${(1..size).map { "    expectsInt(foo(v))" }.joinToString("\n")}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/InferenceFromReturnTypeCallsBenchmark.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class InferenceFromReturnTypeCallsBenchmark : AbstractInferenceBenchmark() {
+
+    @Param("1", "10", "100", "1000", "5000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun <T> foo(x: Int): T = null!!
+            |fun expectsInt(x: Int) {}
+            |fun bar(v: Int) {
+            |${(1..size).map { "    expectsInt(foo(v))" }.joinToString("\n")}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/IntArrayPlusBenchmark.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class IntArrayPlusBenchmark : AbstractSimpleFileBenchmark() {
+
+    @Param("1", "10", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    //@Fork(jvmArgsAppend = ["-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"])
+    fun benchmark(bh: Blackhole) {
+        if (!isIR) error("Doesn't make sense to run it on old frontend on buildserver")
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun bar(x: IntArray, y: IntArray) {
+            |${(1..size).joinToString("\n") { "    x + y" }}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/ManyImplicitReceiversBenchmark.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class ManyImplicitReceiversBenchmark : AbstractSimpleFileBenchmark() {
+    @Param("1", "10", "50")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText(): String {
+        return buildString {
+            appendln("inline fun <T, R> with(receiver: T, block: T.() -> R): R = block()")
+
+            for (i in 1..size) {
+                appendln("interface A$i {")
+                appendln("    fun foo$i()")
+                appendln("}")
+                appendln()
+            }
+            appendln()
+            append("fun test(")
+            append((1..size).joinToString(", ") { "a$it: A$it" })
+            appendln(" {")
+            for (i in 1..size) {
+                appendln("with(a$i) {")
+            }
+            for (i in 1..size) {
+                appendln("foo$i()")
+            }
+            for (i in 1..size) {
+                appendln("}")
+            }
+            appendln("}")
+        }
+    }
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/ManyValsBenchmark.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class ManyValsBenchmark : AbstractSimpleFileBenchmark(){
+
+    @Param("1", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun bar() {
+            |${(1..size).joinToString("\n") { "    val x$it: Int = 1" }}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/ManyVarsBenchmark.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class ManyVarsBenchmark : AbstractSimpleFileBenchmark(){
+
+    @Param("1", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun bar() {
+            |${(1..size).joinToString("\n") { "    var x$it: Int = 1" }}
+            |}
+            """.trimMargin()
+}

benchmarks/src/org/jetbrains/kotlin/benchmarks/SimpleDataFlowBenchmark.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.benchmarks
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+open class SimpleDataFlowBenchmark : AbstractSimpleFileBenchmark(){
+
+    @Param("1", "100", "1000", "3000", "5000", "7000", "10000")
+    private var size: Int = 0
+
+    @Benchmark
+    fun benchmark(bh: Blackhole) {
+        analyzeGreenFile(bh)
+    }
+
+    override fun buildText() =
+            """
+            |fun foo(x: Int): Int = 1
+            |var x = 1
+            |fun bar(v: Int) {
+            |${(1..size).joinToString("\n") { "    x = foo(v)" }}
+            |}
+            """.trimMargin()
+
+
+}

build-common/build.gradle.kts

@@ -13,6 +13,7 @@ dependencies {
     compileOnly(project(":compiler:frontend.java"))
     compileOnly(project(":js:js.serializer"))
     compileOnly(project(":js:js.frontend"))
+    compileOnly(project(":kotlin-util-klib-metadata"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("asm-all", "trove4j", "util", rootProject = rootProject) }
     compileOnly(project(":kotlin-reflect-api"))
@@ -22,8 +23,9 @@ dependencies {
     testCompile(commonDep("junit:junit"))
     testCompile(protobufFull())
     testCompile(kotlinStdlib())
-    testCompileOnly(intellijDep()) { includeJars("openapi") }
-
+    Platform[193].orLower {
+        testCompileOnly(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
+    }
     testRuntime(project(":kotlin-reflect"))
 }
 

build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.incremental
 
 import com.intellij.util.io.DataExternalizer
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumerImpl
+import org.jetbrains.kotlin.incremental.js.IrTranslationResultValue
 import org.jetbrains.kotlin.incremental.js.TranslationResultValue
 import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.metadata.ProtoBuf
@@ -28,6 +29,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.parentOrNull
+import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
 import java.io.DataInput
@@ -36,10 +38,12 @@ import java.io.File
 
 open class IncrementalJsCache(
     cachesDir: File,
-    pathConverter: FileToPathConverter
+    pathConverter: FileToPathConverter,
+    serializerProtocol: SerializerExtensionProtocol
 ) : AbstractIncrementalCache<FqName>(cachesDir, pathConverter) {
     companion object {
         private const val TRANSLATION_RESULT_MAP = "translation-result"
+        private const val IR_TRANSLATION_RESULT_MAP = "ir-translation-result"
         private const val INLINE_FUNCTIONS = "inline-functions"
         private const val HEADER_FILE_NAME = "header.meta"
         private const val PACKAGE_META_FILE = "packages-meta"
@@ -47,9 +51,12 @@ open class IncrementalJsCache(
         fun hasHeaderFile(cachesDir: File) = File(cachesDir, HEADER_FILE_NAME).exists()
     }
 
+    private val protoData = ProtoDataProvider(serializerProtocol)
+
     override val sourceToClassesMap = registerMap(SourceToFqNameMap(SOURCE_TO_CLASSES.storageFile, pathConverter))
     override val dirtyOutputClassesMap = registerMap(DirtyClassesFqNameMap(DIRTY_OUTPUT_CLASSES.storageFile))
-    private val translationResults = registerMap(TranslationResultMap(TRANSLATION_RESULT_MAP.storageFile, pathConverter))
+    private val translationResults = registerMap(TranslationResultMap(TRANSLATION_RESULT_MAP.storageFile, pathConverter, protoData))
+    private val irTranslationResults = registerMap(IrTranslationResultMap(IR_TRANSLATION_RESULT_MAP.storageFile, pathConverter))
     private val inlineFunctions = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile, pathConverter))
     private val packageMetadata = registerMap(PackageMetadataMap(PACKAGE_META_FILE.storageFile))
 
@@ -76,6 +83,17 @@ open class IncrementalJsCache(
         dirtySources.addAll(removedAndCompiledSources)
     }
 
+    fun compare(translatedFiles: Map<File, TranslationResultValue>, changesCollector: ChangesCollector) {
+        for ((srcFile, data) in translatedFiles) {
+            val oldProtoMap = translationResults[srcFile]?.metadata?.let { protoData(srcFile, it) } ?: emptyMap()
+            val newProtoMap = protoData(srcFile, data.metadata)
+
+            for (classId in oldProtoMap.keys + newProtoMap.keys) {
+                changesCollector.collectProtoChanges(oldProtoMap[classId], newProtoMap[classId])
+            }
+        }
+    }
+
     fun compareAndUpdate(incrementalResults: IncrementalResultsConsumerImpl, changesCollector: ChangesCollector) {
         val translatedFiles = incrementalResults.packageParts
 
@@ -83,8 +101,8 @@ open class IncrementalJsCache(
             dirtySources.remove(srcFile)
             val (binaryMetadata, binaryAst, inlineData) = data
 
-            val oldProtoMap = translationResults[srcFile]?.metadata?.let { getProtoData(srcFile, it) } ?: emptyMap()
-            val newProtoMap = getProtoData(srcFile, binaryMetadata)
+            val oldProtoMap = translationResults[srcFile]?.metadata?.let { protoData(srcFile, it) } ?: emptyMap()
+            val newProtoMap = protoData(srcFile, binaryMetadata)
 
             for ((classId, protoData) in newProtoMap) {
                 registerOutputForFile(srcFile, classId.asSingleFqName())
@@ -108,6 +126,11 @@ open class IncrementalJsCache(
         for ((packageName, metadata) in incrementalResults.packageMetadata) {
             packageMetadata.put(packageName, metadata)
         }
+
+        for ((srcFile, irData) in incrementalResults.irFileData) {
+            val (fileData, types, signatures, strings, declarations, bodies, fqn) = irData
+            irTranslationResults.put(srcFile, fileData, types, signatures, strings, declarations, bodies, fqn)
+        }
     }
 
     private fun registerOutputForFile(srcFile: File, name: FqName) {
@@ -118,6 +141,7 @@ open class IncrementalJsCache(
     override fun clearCacheForRemovedClasses(changesCollector: ChangesCollector) {
         dirtySources.forEach {
             translationResults.remove(it, changesCollector)
+            irTranslationResults.remove(it)
             inlineFunctions.remove(it)
         }
         removeAllFromClassStorage(dirtyOutputClassesMap.getDirtyOutputClasses(), changesCollector)
@@ -140,6 +164,16 @@ open class IncrementalJsCache(
             put(fqNameString, packageMetadata[fqNameString]!!)
         }
     }
+
+    fun nonDirtyIrParts(): Map<File, IrTranslationResultValue> =
+        hashMapOf<File, IrTranslationResultValue>().apply {
+            for (file in irTranslationResults.keys()) {
+
+                if (file !in dirtySources) {
+                    put(file, irTranslationResults[file]!!)
+                }
+            }
+        }
 }
 
 private object TranslationResultValueExternalizer : DataExternalizer<TranslationResultValue> {
@@ -173,7 +207,8 @@ private object TranslationResultValueExternalizer : DataExternalizer<Translation
 
 private class TranslationResultMap(
     storageFile: File,
-    private val pathConverter: FileToPathConverter
+    private val pathConverter: FileToPathConverter,
+    private val protoData: ProtoDataProvider
 ) :
     BasicStringMap<TranslationResultValue>(storageFile, TranslationResultValueExternalizer) {
     override fun dumpValue(value: TranslationResultValue): String =
@@ -193,7 +228,7 @@ private class TranslationResultMap(
     fun remove(sourceFile: File, changesCollector: ChangesCollector) {
         val path = pathConverter.toPath(sourceFile)
         val protoBytes = storage[path]!!.metadata
-        val protoMap = getProtoData(sourceFile, protoBytes)
+        val protoMap = protoData(sourceFile, protoBytes)
 
         for ((_, protoData) in protoMap) {
             changesCollector.collectProtoChanges(oldData = protoData, newData = null)
@@ -202,6 +237,104 @@ private class TranslationResultMap(
     }
 }
 
+private object IrTranslationResultValueExternalizer : DataExternalizer<IrTranslationResultValue> {
+    override fun save(output: DataOutput, value: IrTranslationResultValue) {
+        output.writeArray(value.fileData)
+        output.writeArray(value.types)
+        output.writeArray(value.signatures)
+        output.writeArray(value.strings)
+        output.writeArray(value.declarations)
+        output.writeArray(value.bodies)
+        output.writeArray(value.fqn)
+    }
+
+    private fun DataOutput.writeArray(array: ByteArray) {
+        writeInt(array.size)
+        write(array)
+    }
+
+    private fun DataInput.readArray(): ByteArray {
+        val dataSize = readInt()
+        val filedata = ByteArray(dataSize)
+        readFully(filedata)
+        return filedata
+    }
+
+    override fun read(input: DataInput): IrTranslationResultValue {
+        val fileData = input.readArray()
+        val types = input.readArray()
+        val signatures = input.readArray()
+        val strings = input.readArray()
+        val declarations = input.readArray()
+        val bodies = input.readArray()
+        val fqn = input.readArray()
+
+        return IrTranslationResultValue(fileData, types, signatures, strings, declarations, bodies, fqn)
+    }
+}
+
+private class IrTranslationResultMap(
+    storageFile: File,
+    private val pathConverter: FileToPathConverter
+) :
+    BasicStringMap<IrTranslationResultValue>(storageFile, IrTranslationResultValueExternalizer) {
+    override fun dumpValue(value: IrTranslationResultValue): String =
+        "Filedata: ${value.fileData.md5()}, " +
+                "Types: ${value.types.md5()}, " +
+                "Signatures: ${value.signatures.md5()}, " +
+                "Strings: ${value.strings.md5()}, " +
+                "Declarations: ${value.declarations.md5()}, " +
+                "Bodies: ${value.bodies.md5()}"
+
+    fun put(
+        sourceFile: File,
+        newFiledata: ByteArray,
+        newTypes: ByteArray,
+        newSignatures: ByteArray,
+        newStrings: ByteArray,
+        newDeclarations: ByteArray,
+        newBodies: ByteArray,
+        fqn: ByteArray
+    ) {
+        storage[pathConverter.toPath(sourceFile)] =
+            IrTranslationResultValue(newFiledata, newTypes, newSignatures, newStrings, newDeclarations, newBodies, fqn)
+    }
+
+    operator fun get(sourceFile: File): IrTranslationResultValue? =
+        storage[pathConverter.toPath(sourceFile)]
+
+    fun keys(): Collection<File> =
+        storage.keys.map { pathConverter.toFile(it) }
+
+    fun remove(sourceFile: File) {
+        val path = pathConverter.toPath(sourceFile)
+        storage.remove(path)
+    }
+}
+
+private class ProtoDataProvider(private val serializerProtocol: SerializerExtensionProtocol) {
+    operator fun invoke(sourceFile: File, metadata: ByteArray): Map<ClassId, ProtoData> {
+        val classes = hashMapOf<ClassId, ProtoData>()
+        val proto = ProtoBuf.PackageFragment.parseFrom(metadata, serializerProtocol.extensionRegistry)
+        val nameResolver = NameResolverImpl(proto.strings, proto.qualifiedNames)
+
+        proto.class_List.forEach {
+            val classId = nameResolver.getClassId(it.fqName)
+            classes[classId] = ClassProtoData(it, nameResolver)
+        }
+
+        proto.`package`.apply {
+            val packageNameId = getExtensionOrNull(serializerProtocol.packageFqName)
+            val packageFqName = packageNameId?.let { FqName(nameResolver.getPackageFqName(it)) } ?: FqName.ROOT
+            val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalize() + "Kt"))
+            classes[packagePartClassId] = PackagePartProtoData(this, nameResolver, packageFqName)
+        }
+
+        return classes
+    }
+}
+
+// TODO: remove this method once AbstractJsProtoComparisonTest is fixed
 fun getProtoData(sourceFile: File, metadata: ByteArray): Map<ClassId, ProtoData> {
     val classes = hashMapOf<ClassId, ProtoData>()
     val proto = ProtoBuf.PackageFragment.parseFrom(metadata, JsSerializerProtocol.extensionRegistry)

build-common/src/org/jetbrains/kotlin/incremental/JavaClassesSerializerExtension.kt

@@ -55,10 +55,13 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
         }
     }
 
-    override fun serializeFunction(descriptor: FunctionDescriptor,
-                                   proto: ProtoBuf.Function.Builder,
-                                   childSerializer: DescriptorSerializer) {
-        super.serializeFunction(descriptor, proto, childSerializer)
+    override fun serializeFunction(
+        descriptor: FunctionDescriptor,
+        proto: ProtoBuf.Function.Builder,
+        versionRequirementTable: MutableVersionRequirementTable?,
+        childSerializer: DescriptorSerializer
+    ) {
+        super.serializeFunction(descriptor, proto, versionRequirementTable, childSerializer)
         if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateMethod, true)
         }

build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt

@@ -28,9 +28,8 @@ 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 org.jetbrains.kotlin.resolve.sam.SAM_LOOKUP_NAME
 import org.jetbrains.kotlin.utils.addToStdlib.flattenTo
-import org.jetbrains.kotlin.utils.keysToMap
 import java.io.File
 import java.util.*
 import kotlin.collections.HashSet

build-common/src/org/jetbrains/kotlin/incremental/js/IncrementalDataProviderFromCache.kt

@@ -21,4 +21,7 @@ class IncrementalDataProviderFromCache(private val cache: IncrementalJsCache) :
 
     override val packageMetadata: Map<String, ByteArray>
         get() = cache.packageMetadata()
+
+    override val serializedIrFiles: Map<File, IrTranslationResultValue>
+        get() = cache.nonDirtyIrParts()
 }

build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt

@@ -30,9 +30,9 @@ import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import java.util.*
 
 data class Difference(
-        val isClassAffected: Boolean = false,
-        val areSubclassesAffected: Boolean = false,
-        val changedMembersNames: Set<String> = emptySet()
+    val isClassAffected: Boolean = false,
+    val areSubclassesAffected: Boolean = false,
+    val changedMembersNames: Set<String> = emptySet()
 )
 
 sealed class ProtoData
@@ -49,14 +49,17 @@ fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
     }
 
 internal val MessageLite.isPrivate: Boolean
-    get() = Visibilities.isPrivate(ProtoEnumFlags.visibility(
+    get() = Visibilities.isPrivate(
+        ProtoEnumFlags.visibility(
             when (this) {
                 is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.Function -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.Property -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.TypeAlias -> Flags.VISIBILITY.get(flags)
                 else -> error("Unknown message: $this")
-            }))
+            }
+        )
+    )
 
 private fun MessageLite.name(nameResolver: NameResolver): String {
     return when (this) {
@@ -79,9 +82,21 @@ abstract class DifferenceCalculator {
         val result = hashSetOf<String>()
 
         val oldMap =
-                oldList.groupBy { it.getHashCode({ compareObject.oldGetIndexOfString(it) }, { compareObject.oldGetIndexOfClassId(it) }) }
+            oldList.groupBy {
+                it.getHashCode(
+                    compareObject::oldGetIndexOfString,
+                    compareObject::oldGetIndexOfClassId,
+                    compareObject::oldGetTypeById
+                )
+            }
         val newMap =
-                newList.groupBy { it.getHashCode({ compareObject.newGetIndexOfString(it) }, { compareObject.newGetIndexOfClassId(it) }) }
+            newList.groupBy {
+                it.getHashCode(
+                    compareObject::newGetIndexOfString,
+                    compareObject::newGetIndexOfClassId,
+                    compareObject::newGetTypeById
+                )
+            }
 
         val hashes = oldMap.keys + newMap.keys
         for (hash in hashes) {
@@ -100,8 +115,8 @@ abstract class DifferenceCalculator {
     }
 
     private fun calcDifferenceForEqualHashes(
-            oldList: List<MessageLite>,
-            newList: List<MessageLite>
+        oldList: List<MessageLite>,
+        newList: List<MessageLite>
     ): Collection<String> {
         val result = hashSetOf<String>()
         val newSet = HashSet(newList)
@@ -110,8 +125,7 @@ abstract class DifferenceCalculator {
             val newMember = newSet.firstOrNull { compareObject.checkEquals(oldMember, it) }
             if (newMember != null) {
                 newSet.remove(newMember)
-            }
-            else {
+            } else {
                 result.add(oldMember.name(compareObject.oldNameResolver))
             }
         }
@@ -124,20 +138,20 @@ abstract class DifferenceCalculator {
     }
 
     protected fun calcDifferenceForNames(
-            oldList: List<Int>,
-            newList: List<Int>
+        oldList: List<Int>,
+        newList: List<Int>
     ): Collection<String> {
         val oldNames = oldList.map { compareObject.oldNameResolver.getString(it) }.toSet()
         val newNames = newList.map { compareObject.newNameResolver.getString(it) }.toSet()
         return oldNames.union(newNames) - oldNames.intersect(newNames)
     }
 
-    private fun MessageLite.getHashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int {
+    private fun MessageLite.getHashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int, typeTable: (Int) -> ProtoBuf.Type): Int {
         return when (this) {
-            is ProtoBuf.Constructor -> hashCode(stringIndexes, fqNameIndexes)
-            is ProtoBuf.Function -> hashCode(stringIndexes, fqNameIndexes)
-            is ProtoBuf.Property -> hashCode(stringIndexes, fqNameIndexes)
-            is ProtoBuf.TypeAlias -> hashCode(stringIndexes, fqNameIndexes)
+            is ProtoBuf.Constructor -> hashCode(stringIndexes, fqNameIndexes, typeTable)
+            is ProtoBuf.Function -> hashCode(stringIndexes, fqNameIndexes, typeTable)
+            is ProtoBuf.Property -> hashCode(stringIndexes, fqNameIndexes, typeTable)
+            is ProtoBuf.TypeAlias -> hashCode(stringIndexes, fqNameIndexes, typeTable)
             else -> error("Unknown message: $this")
         }
     }
@@ -154,10 +168,15 @@ abstract class DifferenceCalculator {
 }
 
 class DifferenceCalculatorForClass(
-        private val oldData: ClassProtoData,
-        private val newData: ClassProtoData
+    private val oldData: ClassProtoData,
+    private val newData: ClassProtoData
 ) : DifferenceCalculator() {
-    override val compareObject = ProtoCompareGenerated(oldData.nameResolver, newData.nameResolver)
+    override val compareObject = ProtoCompareGenerated(
+        oldNameResolver = oldData.nameResolver,
+        newNameResolver = newData.nameResolver,
+        oldTypeTable = oldData.proto.typeTableOrNull,
+        newTypeTable = newData.proto.typeTableOrNull
+    )
 
     override fun difference(): Difference {
         val (oldProto, oldNameResolver) = oldData
@@ -220,11 +239,8 @@ class DifferenceCalculatorForClass(
                     //     when (x as Base) { is Impl -> ... }
                     areSubclassesAffected = true
                 }
-                ProtoBufClassKind.TYPE_TABLE -> {
-                    // TODO
-                }
-                ProtoCompareGenerated.ProtoBufClassKind.VERSION_REQUIREMENT_LIST,
-                ProtoCompareGenerated.ProtoBufClassKind.VERSION_REQUIREMENT_TABLE -> {
+                ProtoBufClassKind.VERSION_REQUIREMENT_LIST,
+                ProtoBufClassKind.VERSION_REQUIREMENT_TABLE -> {
                     // TODO
                 }
                 ProtoBufClassKind.FLAGS,
@@ -238,7 +254,7 @@ class DifferenceCalculatorForClass(
                 }
                 ProtoBufClassKind.JVM_EXT_CLASS_MODULE_NAME,
                 ProtoBufClassKind.JS_EXT_CLASS_CONTAINING_FILE_ID -> {
-                   // TODO
+                    // TODO
                 }
                 ProtoBufClassKind.JVM_EXT_CLASS_LOCAL_VARIABLE_LIST -> {
                     // Not affected, local variables are not accessible outside of a file
@@ -250,9 +266,13 @@ class DifferenceCalculatorForClass(
                 ProtoBufClassKind.BUILT_INS_EXT_CLASS_ANNOTATION_LIST -> {
                     isClassAffected = true
                 }
-                ProtoCompareGenerated.ProtoBufClassKind.JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME -> {
+                ProtoBufClassKind.JVM_EXT_ANONYMOUS_OBJECT_ORIGIN_NAME -> {
                     // Not affected, this extension is not used in the compiler
                 }
+                ProtoBufClassKind.KLIB_EXT_CLASS_ANNOTATION_LIST -> {
+                    isClassAffected = true
+                    areSubclassesAffected = true
+                }
             }
         }
 
@@ -261,10 +281,15 @@ class DifferenceCalculatorForClass(
 }
 
 class DifferenceCalculatorForPackageFacade(
-        private val oldData: PackagePartProtoData,
-        private val newData: PackagePartProtoData
+    private val oldData: PackagePartProtoData,
+    private val newData: PackagePartProtoData
 ) : DifferenceCalculator() {
-    override val compareObject = ProtoCompareGenerated(oldData.nameResolver, newData.nameResolver)
+    override val compareObject = ProtoCompareGenerated(
+        oldNameResolver = oldData.nameResolver,
+        newNameResolver = newData.nameResolver,
+        oldTypeTable = oldData.proto.typeTableOrNull,
+        newTypeTable = newData.proto.typeTableOrNull
+    )
 
     override fun difference(): Difference {
         val oldProto = oldData.proto
@@ -289,10 +314,9 @@ class DifferenceCalculatorForPackageFacade(
                     names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Package::getPropertyList))
                 ProtoBufPackageKind.TYPE_ALIAS_LIST ->
                     names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Package::getTypeAliasList))
-                ProtoBufPackageKind.TYPE_TABLE,
                 ProtoBufPackageKind.VERSION_REQUIREMENT_TABLE,
                 ProtoBufPackageKind.JVM_EXT_PACKAGE_MODULE_NAME,
-                ProtoBufPackageKind.JS_EXT_PACKAGE_FQ_NAME-> {
+                ProtoBufPackageKind.JS_EXT_PACKAGE_FQ_NAME -> {
                     // TODO
                 }
                 ProtoBufPackageKind.JVM_EXT_PACKAGE_LOCAL_VARIABLE_LIST -> {
@@ -301,6 +325,9 @@ class DifferenceCalculatorForPackageFacade(
                 ProtoBufPackageKind.BUILT_INS_EXT_PACKAGE_FQ_NAME -> {
                     // Not affected
                 }
+                ProtoBufPackageKind.KLIB_EXT_PACKAGE_FQ_NAME -> {
+                    // Not affected
+                }
             }
         }
 
@@ -310,3 +337,9 @@ class DifferenceCalculatorForPackageFacade(
 
 private val ProtoBuf.Class.isSealed: Boolean
     get() = ProtoBuf.Modality.SEALED == Flags.MODALITY.get(flags)
+
+val ProtoBuf.Class.typeTableOrNull: ProtoBuf.TypeTable?
+    get() = if (hasTypeTable()) typeTable else null
+
+val ProtoBuf.Package.typeTableOrNull: ProtoBuf.TypeTable?
+    get() = if (hasTypeTable()) typeTable else null

build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt

@@ -24,11 +24,20 @@ import org.jetbrains.kotlin.utils.Printer
 import java.io.File
 
 abstract class BasicMap<K : Comparable<K>, V>(
-        storageFile: File,
+        internal val storageFile: File,
         keyDescriptor: KeyDescriptor<K>,
         valueExternalizer: DataExternalizer<V>
 ) {
-    protected val storage = LazyStorage(storageFile, keyDescriptor, valueExternalizer)
+    protected val storage: LazyStorage<K, V>
+    private val nonCachingStorage = System.getProperty("kotlin.jps.non.caching.storage")?.toBoolean() ?: false
+
+    init {
+        storage = if (nonCachingStorage) {
+            NonCachingLazyStorage(storageFile, keyDescriptor, valueExternalizer)
+        } else {
+            CachingLazyStorage(storageFile, keyDescriptor, valueExternalizer)
+        }
+    }
 
     fun clean() {
         storage.clean()

build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt.191

@@ -0,0 +1,81 @@
+/*
+ * 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.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.EnumeratorStringDescriptor
+import com.intellij.util.io.KeyDescriptor
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.utils.Printer
+import java.io.File
+
+abstract class BasicMap<K : Comparable<K>, V>(
+        internal val storageFile: File,
+        keyDescriptor: KeyDescriptor<K>,
+        valueExternalizer: DataExternalizer<V>
+) {
+    protected val storage = LazyStorage(storageFile, keyDescriptor, valueExternalizer)
+
+    fun clean() {
+        storage.clean()
+    }
+
+    fun flush(memoryCachesOnly: Boolean) {
+        storage.flush(memoryCachesOnly)
+    }
+
+    fun close() {
+        storage.close()
+    }
+
+    @TestOnly
+    fun dump(): String {
+        return with(StringBuilder()) {
+            with(Printer(this)) {
+                println(this@BasicMap::class.java.simpleName)
+                pushIndent()
+
+                for (key in storage.keys.sorted()) {
+                    println("${dumpKey(key)} -> ${dumpValue(storage[key]!!)}")
+                }
+
+                popIndent()
+            }
+
+            this
+        }.toString()
+    }
+
+    @TestOnly
+    protected abstract fun dumpKey(key: K): String
+
+    @TestOnly
+    protected abstract fun dumpValue(value: V): String
+}
+
+abstract class BasicStringMap<V>(
+        storageFile: File,
+        keyDescriptor: KeyDescriptor<String>,
+        valueExternalizer: DataExternalizer<V>
+) : BasicMap<String, V>(storageFile, keyDescriptor, valueExternalizer) {
+    constructor(
+            storageFile: File,
+            valueExternalizer: DataExternalizer<V>
+    ) : this(storageFile, EnumeratorStringDescriptor.INSTANCE, valueExternalizer)
+
+    override fun dumpKey(key: String): String = key
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt.192

@@ -1,90 +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.incremental.storage
-
-import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.EnumeratorStringDescriptor
-import com.intellij.util.io.KeyDescriptor
-import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.utils.Printer
-import java.io.File
-
-abstract class BasicMap<K : Comparable<K>, V>(
-        storageFile: File,
-        keyDescriptor: KeyDescriptor<K>,
-        valueExternalizer: DataExternalizer<V>
-) {
-    protected val storage: LazyStorage<K, V>
-    private val nonCachingStorage = System.getProperty("kotlin.jps.non.caching.storage")?.toBoolean() ?: false
-
-    init {
-        storage = if (nonCachingStorage) {
-            NonCachingLazyStorage(storageFile, keyDescriptor, valueExternalizer)
-        } else {
-            CachingLazyStorage(storageFile, keyDescriptor, valueExternalizer)
-        }
-    }
-
-    fun clean() {
-        storage.clean()
-    }
-
-    fun flush(memoryCachesOnly: Boolean) {
-        storage.flush(memoryCachesOnly)
-    }
-
-    fun close() {
-        storage.close()
-    }
-
-    @TestOnly
-    fun dump(): String {
-        return with(StringBuilder()) {
-            with(Printer(this)) {
-                println(this@BasicMap::class.java.simpleName)
-                pushIndent()
-
-                for (key in storage.keys.sorted()) {
-                    println("${dumpKey(key)} -> ${dumpValue(storage[key]!!)}")
-                }
-
-                popIndent()
-            }
-
-            this
-        }.toString()
-    }
-
-    @TestOnly
-    protected abstract fun dumpKey(key: K): String
-
-    @TestOnly
-    protected abstract fun dumpValue(value: V): String
-}
-
-abstract class BasicStringMap<V>(
-        storageFile: File,
-        keyDescriptor: KeyDescriptor<String>,
-        valueExternalizer: DataExternalizer<V>
-) : BasicMap<String, V>(storageFile, keyDescriptor, valueExternalizer) {
-    constructor(
-            storageFile: File,
-            valueExternalizer: DataExternalizer<V>
-    ) : this(storageFile, EnumeratorStringDescriptor.INSTANCE, valueExternalizer)
-
-    override fun dumpKey(key: String): String = key
-}

build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import org.jetbrains.annotations.TestOnly
 import java.io.File
+import java.io.IOException
 
 open class BasicMapsOwner(val cachesDir: File) {
     private val maps = arrayListOf<BasicMap<*, *>>()
@@ -35,16 +36,35 @@ open class BasicMapsOwner(val cachesDir: File) {
     }
 
     open fun clean() {
-        maps.forEach { it.clean() }
+        forEachMapSafe("clean", BasicMap<*, *>::clean)
     }
 
     open fun close() {
-        maps.forEach { it.close() }
+        forEachMapSafe("close", BasicMap<*, *>::close)
     }
 
     open fun flush(memoryCachesOnly: Boolean) {
-        maps.forEach { it.flush(memoryCachesOnly) }
+        forEachMapSafe("flush") { it.flush(memoryCachesOnly) }
     }
 
-    @TestOnly fun dump(): String = maps.joinToString("\n\n") { it.dump() }
+    private fun forEachMapSafe(actionName: String, action: (BasicMap<*, *>) -> Unit) {
+        val actionExceptions = LinkedHashMap<String, Exception>()
+        maps.forEach {
+            try {
+                action(it)
+            } catch (e: Exception) {
+                actionExceptions[it.storageFile.name] = e
+            }
+        }
+        if (actionExceptions.isNotEmpty()) {
+            val desc = "Could not $actionName incremental caches in $cachesDir: ${actionExceptions.keys.joinToString(", ")}"
+            val allIOExceptions = actionExceptions.all { it is IOException }
+            val ex = if (allIOExceptions) IOException(desc) else Exception(desc)
+            actionExceptions.forEach { (_, e) -> ex.addSuppressed(e) }
+            throw ex
+        }
+    }
+
+    @TestOnly
+    fun dump(): String = maps.joinToString("\n\n") { it.dump() }
 }

build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt

@@ -0,0 +1,107 @@
+/*
+ * 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.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.PersistentHashMap
+import java.io.File
+
+
+/**
+ * It's lazy in a sense that PersistentHashMap is created only on write
+ */
+class CachingLazyStorage<K, V>(
+    private val storageFile: File,
+    private val keyDescriptor: KeyDescriptor<K>,
+    private val valueExternalizer: DataExternalizer<V>
+) : LazyStorage<K, V> {
+    @Volatile
+    private var storage: PersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    override val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    override operator fun contains(key: K): Boolean =
+        getStorageIfExists()?.containsMapping(key) ?: false
+
+    override operator fun get(key: K): V? =
+        getStorageIfExists()?.get(key)
+
+    override operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    override fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    override fun append(key: K, value: V) {
+        getStorageOrCreateNew().appendData(key, { valueExternalizer.save(it, value) })
+    }
+
+    @Synchronized
+    override fun clean() {
+        try {
+            storage?.close()
+        } finally {
+            PersistentHashMap.deleteFilesStartingWith(storageFile)
+            storage = null
+        }
+    }
+
+    @Synchronized
+    override fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        } else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    override fun close() {
+        storage?.close()
+    }
+
+    private fun createMap(): PersistentHashMap<K, V> = PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt.192

@@ -1,108 +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.incremental.storage
-
-import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.PersistentHashMap
-import java.io.File
-
-
-/**
- * It's lazy in a sense that PersistentHashMap is created only on write
- */
-class CachingLazyStorage<K, V>(
-    private val storageFile: File,
-    private val keyDescriptor: KeyDescriptor<K>,
-    private val valueExternalizer: DataExternalizer<V>
-) : LazyStorage<K, V> {
-    @Volatile
-    private var storage: PersistentHashMap<K, V>? = null
-
-    @Synchronized
-    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
-        if (storage != null) return storage
-
-        if (storageFile.exists()) {
-            storage = createMap()
-            return storage
-        }
-
-        return null
-    }
-
-    @Synchronized
-    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
-        if (storage == null) {
-            storage = createMap()
-        }
-
-        return storage!!
-    }
-
-    override val keys: Collection<K>
-        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
-
-    override operator fun contains(key: K): Boolean =
-        getStorageIfExists()?.containsMapping(key) ?: false
-
-    override operator fun get(key: K): V? =
-        getStorageIfExists()?.get(key)
-
-    override operator fun set(key: K, value: V) {
-        getStorageOrCreateNew().put(key, value)
-    }
-
-    override fun remove(key: K) {
-        getStorageIfExists()?.remove(key)
-    }
-
-    override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendData(key, { valueExternalizer.save(it, value) })
-    }
-
-    @Synchronized
-    override fun clean() {
-        try {
-            storage?.close()
-        } catch (ignored: Throwable) {
-        }
-
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
-    }
-
-    @Synchronized
-    override fun flush(memoryCachesOnly: Boolean) {
-        val existingStorage = storage ?: return
-
-        if (memoryCachesOnly) {
-            if (existingStorage.isDirty) {
-                existingStorage.dropMemoryCaches()
-            }
-        } else {
-            existingStorage.force()
-        }
-    }
-
-    @Synchronized
-    override fun close() {
-        storage?.close()
-    }
-
-    private fun createMap(): PersistentHashMap<K, V> = PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
-}

build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt

@@ -26,7 +26,7 @@ internal open class ClassOneToManyMap(
     override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
 
     fun add(key: FqName, value: FqName) {
-        storage.append(key.asString(), value.asString())
+        storage.append(key.asString(), listOf(value.asString()))
     }
 
     operator fun get(key: FqName): Collection<FqName> =

build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt.191

@@ -0,0 +1,55 @@
+/*
+ * 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.incremental.storage
+
+import org.jetbrains.kotlin.incremental.dumpCollection
+import org.jetbrains.kotlin.name.FqName
+import java.io.File
+
+internal open class ClassOneToManyMap(
+        storageFile: File
+) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
+    override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
+
+    fun add(key: FqName, value: FqName) {
+        storage.append(key.asString(), value.asString())
+    }
+
+    operator fun get(key: FqName): Collection<FqName> =
+            storage[key.asString()]?.map(::FqName) ?: setOf()
+
+    operator fun set(key: FqName, values: Collection<FqName>) {
+        if (values.isEmpty()) {
+            remove(key)
+            return
+        }
+
+        storage[key.asString()] = values.map(FqName::asString)
+    }
+
+    fun remove(key: FqName) {
+        storage.remove(key.asString())
+    }
+
+    fun removeValues(key: FqName, removed: Set<FqName>) {
+        val notRemoved = this[key].filter { it !in removed }
+        this[key] = notRemoved
+    }
+}
+
+internal class SubtypesMap(storageFile: File) : ClassOneToManyMap(storageFile)
+internal class SupertypesMap(storageFile: File) : ClassOneToManyMap(storageFile)

build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt.192

@@ -1,55 +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.incremental.storage
-
-import org.jetbrains.kotlin.incremental.dumpCollection
-import org.jetbrains.kotlin.name.FqName
-import java.io.File
-
-internal open class ClassOneToManyMap(
-        storageFile: File
-) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
-    override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
-
-    fun add(key: FqName, value: FqName) {
-        storage.append(key.asString(), listOf(value.asString()))
-    }
-
-    operator fun get(key: FqName): Collection<FqName> =
-            storage[key.asString()]?.map(::FqName) ?: setOf()
-
-    operator fun set(key: FqName, values: Collection<FqName>) {
-        if (values.isEmpty()) {
-            remove(key)
-            return
-        }
-
-        storage[key.asString()] = values.map(FqName::asString)
-    }
-
-    fun remove(key: FqName) {
-        storage.remove(key.asString())
-    }
-
-    fun removeValues(key: FqName, removed: Set<FqName>) {
-        val notRemoved = this[key].filter { it !in removed }
-        this[key] = notRemoved
-    }
-}
-
-internal class SubtypesMap(storageFile: File) : ClassOneToManyMap(storageFile)
-internal class SupertypesMap(storageFile: File) : ClassOneToManyMap(storageFile)

build-common/src/org/jetbrains/kotlin/incremental/storage/LazyStorage.kt

@@ -16,107 +16,14 @@
 
 package org.jetbrains.kotlin.incremental.storage
 
-import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.IOUtil
-import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.PersistentHashMap
-import java.io.DataOutput
-import java.io.File
-import java.io.IOException
-
-
-/**
- * It's lazy in a sense that PersistentHashMap is created only on write
- */
-class LazyStorage<K, V>(
-        private val storageFile: File,
-        private val keyDescriptor: KeyDescriptor<K>,
-        private val valueExternalizer: DataExternalizer<V>
-) {
-    @Volatile
-    private var storage: PersistentHashMap<K, V>? = null
-
-    @Synchronized
-    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
-        if (storage != null) return storage
-
-        if (storageFile.exists()) {
-            storage = createMap()
-            return storage
-        }
-
-        return null
-    }
-
-    @Synchronized
-    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
-        if (storage == null) {
-            storage = createMap()
-        }
-
-        return storage!!
-    }
-
+interface LazyStorage<K, V> {
     val keys: Collection<K>
-        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
-
-    operator fun contains(key: K): Boolean =
-            getStorageIfExists()?.containsMapping(key) ?: false
-
-    operator fun get(key: K): V? =
-            getStorageIfExists()?.get(key)
-
-    operator fun set(key: K, value: V) {
-        getStorageOrCreateNew().put(key, value)
-    }
-
-    fun remove(key: K) {
-        getStorageIfExists()?.remove(key)
-    }
-
-    fun append(key: K, value: String) {
-        append(key) { out -> IOUtil.writeUTF(out, value) }
-    }
-
-    fun append(key: K, value: Int) {
-        append(key) { out -> out.writeInt(value) }
-    }
-
-    @Synchronized
-    fun clean() {
-        try {
-            storage?.close()
-        }
-        catch (ignored: Throwable) {
-        }
-
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
-    }
-
-    @Synchronized
-    fun flush(memoryCachesOnly: Boolean) {
-        val existingStorage = storage ?: return
-
-        if (memoryCachesOnly) {
-            if (existingStorage.isDirty) {
-                existingStorage.dropMemoryCaches()
-            }
-        }
-        else {
-            existingStorage.force()
-        }
-    }
-
-    @Synchronized
-    fun close() {
-        storage?.close()
-    }
-
-    private fun createMap(): PersistentHashMap<K, V> =
-            PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
-
-    private fun append(key: K, append: (DataOutput)->Unit) {
-        getStorageOrCreateNew().appendData(key, append)
-    }
-}
+    operator fun contains(key: K): Boolean
+    operator fun get(key: K): V?
+    operator fun set(key: K, value: V)
+    fun remove(key: K)
+    fun append(key: K, value: V)
+    fun clean()
+    fun flush(memoryCachesOnly: Boolean)
+    fun close()
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/LazyStorage.kt.191

@@ -0,0 +1,122 @@
+/*
+ * 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.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.IOUtil
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.PersistentHashMap
+import java.io.DataOutput
+import java.io.File
+import java.io.IOException
+
+
+/**
+ * It's lazy in a sense that PersistentHashMap is created only on write
+ */
+class LazyStorage<K, V>(
+        private val storageFile: File,
+        private val keyDescriptor: KeyDescriptor<K>,
+        private val valueExternalizer: DataExternalizer<V>
+) {
+    @Volatile
+    private var storage: PersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    operator fun contains(key: K): Boolean =
+            getStorageIfExists()?.containsMapping(key) ?: false
+
+    operator fun get(key: K): V? =
+            getStorageIfExists()?.get(key)
+
+    operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    fun append(key: K, value: String) {
+        append(key) { out -> IOUtil.writeUTF(out, value) }
+    }
+
+    fun append(key: K, value: Int) {
+        append(key) { out -> out.writeInt(value) }
+    }
+
+    @Synchronized
+    fun clean() {
+        try {
+            storage?.close()
+        }
+        catch (ignored: Throwable) {
+        }
+
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
+    }
+
+    @Synchronized
+    fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        }
+        else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    fun close() {
+        storage?.close()
+    }
+
+    private fun createMap(): PersistentHashMap<K, V> =
+            PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+
+    private fun append(key: K, append: (DataOutput)->Unit) {
+        getStorageOrCreateNew().appendData(key, append)
+    }
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/LazyStorage.kt.192

@@ -1,29 +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.incremental.storage
-
-interface LazyStorage<K, V> {
-    val keys: Collection<K>
-    operator fun contains(key: K): Boolean
-    operator fun get(key: K): V?
-    operator fun set(key: K, value: V)
-    fun remove(key: K)
-    fun append(key: K, value: V)
-    fun clean()
-    fun flush(memoryCachesOnly: Boolean)
-    fun close()
-}

build-common/src/org/jetbrains/kotlin/incremental/storage/LookupMap.kt

@@ -24,7 +24,7 @@ internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<I
     override fun dumpValue(value: Collection<Int>): String = value.toString()
 
     fun add(name: String, scope: String, fileId: Int) {
-        storage.append(LookupSymbolKey(name, scope), fileId)
+        storage.append(LookupSymbolKey(name, scope), listOf(fileId))
     }
 
     operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]

build-common/src/org/jetbrains/kotlin/incremental/storage/LookupMap.kt.191

@@ -0,0 +1,42 @@
+/*
+ * 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.incremental.storage
+
+import java.io.File
+
+internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) {
+    override fun dumpKey(key: LookupSymbolKey): String = key.toString()
+
+    override fun dumpValue(value: Collection<Int>): String = value.toString()
+
+    fun add(name: String, scope: String, fileId: Int) {
+        storage.append(LookupSymbolKey(name, scope), fileId)
+    }
+
+    operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]
+
+    operator fun set(key: LookupSymbolKey, fileIds: Set<Int>) {
+        storage[key] = fileIds
+    }
+
+    fun remove(key: LookupSymbolKey) {
+        storage.remove(key)
+    }
+
+    val keys: Collection<LookupSymbolKey>
+        get() = storage.keys
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/LookupMap.kt.192

@@ -1,42 +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.incremental.storage
-
-import java.io.File
-
-internal class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) {
-    override fun dumpKey(key: LookupSymbolKey): String = key.toString()
-
-    override fun dumpValue(value: Collection<Int>): String = value.toString()
-
-    fun add(name: String, scope: String, fileId: Int) {
-        storage.append(LookupSymbolKey(name, scope), listOf(fileId))
-    }
-
-    operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]
-
-    operator fun set(key: LookupSymbolKey, fileIds: Set<Int>) {
-        storage[key] = fileIds
-    }
-
-    fun remove(key: LookupSymbolKey) {
-        storage.remove(key)
-    }
-
-    val keys: Collection<LookupSymbolKey>
-        get() = storage.keys
-}

build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt.201

@@ -0,0 +1,106 @@
+/*
+ * 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.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.PersistentHashMap
+import java.io.File
+
+
+class NonCachingLazyStorage<K, V>(
+    private val storageFile: File,
+    private val keyDescriptor: KeyDescriptor<K>,
+    private val valueExternalizer: DataExternalizer<V>
+) : LazyStorage<K, V> {
+    @Volatile
+    private var storage: PersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    override val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    override operator fun contains(key: K): Boolean =
+        getStorageIfExists()?.containsMapping(key) ?: false
+
+    override operator fun get(key: K): V? =
+        getStorageIfExists()?.get(key)
+
+    override operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    override fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    override fun append(key: K, value: V) {
+        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
+    }
+
+    @Synchronized
+    override fun clean() {
+        try {
+            storage?.close()
+        } catch (ignored: Throwable) {
+        }
+
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
+    }
+
+    @Synchronized
+    override fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        } else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    override fun close() {
+        storage?.close()
+    }
+
+    private fun createMap(): PersistentHashMap<K, V> =
+        PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt

@@ -41,7 +41,7 @@ internal abstract class AbstractSourceToOutputMap<Name>(
     }
 
     fun add(sourceFile: File, className: Name) {
-        storage.append(pathConverter.toPath(sourceFile), nameTransformer.asString(className))
+        storage.append(pathConverter.toPath(sourceFile), listOf(nameTransformer.asString(className)))
     }
 
     fun contains(sourceFile: File): Boolean =

build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt.191

@@ -0,0 +1,62 @@
+/*
+ * 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,
+    pathConverter: FileToPathConverter
+) : AbstractSourceToOutputMap<JvmClassName>(JvmClassNameTransformer, storageFile, pathConverter)
+
+internal class SourceToFqNameMap(
+    storageFile: File,
+    pathConverter: FileToPathConverter
+) : AbstractSourceToOutputMap<FqName>(FqNameTransformer, storageFile, pathConverter)
+
+internal abstract class AbstractSourceToOutputMap<Name>(
+    private val nameTransformer: NameTransformer<Name>,
+    storageFile: File,
+    private val pathConverter: FileToPathConverter
+) : BasicStringMap<Collection<String>>(storageFile, PathStringDescriptor, StringCollectionExternalizer) {
+    fun clearOutputsForSource(sourceFile: File) {
+        remove(pathConverter.toPath(sourceFile))
+    }
+
+    fun add(sourceFile: File, className: Name) {
+        storage.append(pathConverter.toPath(sourceFile), nameTransformer.asString(className))
+    }
+
+    fun contains(sourceFile: File): Boolean =
+        pathConverter.toPath(sourceFile) in storage
+
+    operator fun get(sourceFile: File): Collection<Name> =
+        storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asName)
+
+    fun getFqNames(sourceFile: File): Collection<FqName> =
+        storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asFqName)
+
+    override fun dumpValue(value: Collection<String>) =
+        value.dumpCollection()
+
+    private fun remove(path: String) {
+        storage.remove(path)
+    }
+}

build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt.192

@@ -1,62 +0,0 @@
-/*
- * 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,
-    pathConverter: FileToPathConverter
-) : AbstractSourceToOutputMap<JvmClassName>(JvmClassNameTransformer, storageFile, pathConverter)
-
-internal class SourceToFqNameMap(
-    storageFile: File,
-    pathConverter: FileToPathConverter
-) : AbstractSourceToOutputMap<FqName>(FqNameTransformer, storageFile, pathConverter)
-
-internal abstract class AbstractSourceToOutputMap<Name>(
-    private val nameTransformer: NameTransformer<Name>,
-    storageFile: File,
-    private val pathConverter: FileToPathConverter
-) : BasicStringMap<Collection<String>>(storageFile, PathStringDescriptor, StringCollectionExternalizer) {
-    fun clearOutputsForSource(sourceFile: File) {
-        remove(pathConverter.toPath(sourceFile))
-    }
-
-    fun add(sourceFile: File, className: Name) {
-        storage.append(pathConverter.toPath(sourceFile), listOf(nameTransformer.asString(className)))
-    }
-
-    fun contains(sourceFile: File): Boolean =
-        pathConverter.toPath(sourceFile) in storage
-
-    operator fun get(sourceFile: File): Collection<Name> =
-        storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asName)
-
-    fun getFqNames(sourceFile: File): Collection<FqName> =
-        storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asFqName)
-
-    override fun dumpValue(value: Collection<String>) =
-        value.dumpCollection()
-
-    private fun remove(path: String) {
-        storage.remove(path)
-    }
-}

build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt

@@ -19,12 +19,16 @@ package org.jetbrains.kotlin.incremental.testingUtils
 import java.io.File
 
 data class BuildLogFinder(
-        private val isDataContainerBuildLogEnabled: Boolean = false,
-        private val isGradleEnabled: Boolean = false,
-        private val isJsEnabled: Boolean = false
+    private val isDataContainerBuildLogEnabled: Boolean = false,
+    private val isGradleEnabled: Boolean = false,
+    private val isJsEnabled: Boolean = false,
+    private val isJsIrEnabled: Boolean = false, // TODO rename as it is used for metadata-only test
+    private val isScopeExpansionEnabled: Boolean = false
 ) {
     companion object {
         private const val JS_LOG = "js-build.log"
+        private const val JS_IR_LOG = "js-ir-build.log"
+        private const val SCOPE_EXPANDING_LOG = "build-with-scope-expansion.log"
         private const val GRADLE_LOG = "gradle-build.log"
         private const val DATA_CONTAINER_LOG = "data-container-version-build.log"
         const val JS_JPS_LOG = "js-jps-build.log"
@@ -38,6 +42,8 @@ data class BuildLogFinder(
         val names = dir.list() ?: arrayOf()
         val files = names.filter { File(dir, it).isFile }.toSet()
         val matchedName = when {
+            isScopeExpansionEnabled && SCOPE_EXPANDING_LOG in files -> SCOPE_EXPANDING_LOG
+            isJsIrEnabled && JS_IR_LOG in files -> JS_IR_LOG
             isJsEnabled && JS_LOG in files -> JS_LOG
             isGradleEnabled && GRADLE_LOG in files -> GRADLE_LOG
             isJsEnabled && JS_JPS_LOG in files -> JS_JPS_LOG

build-common/test/org/jetbrains/kotlin/metadata/DebugExtOptionsProtoBuf.java

@@ -11,6 +11,8 @@ public final class DebugExtOptionsProtoBuf {
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.stringIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.skipMessageInComparison);
   }
   public static final int SKIP_IN_COMPARISON_FIELD_NUMBER = 50000;
   /**
@@ -56,6 +58,28 @@ public final class DebugExtOptionsProtoBuf {
           .newFileScopedGeneratedExtension(
         java.lang.Boolean.class,
         null);
+  public static final int TYPE_ID_IN_TABLE_FIELD_NUMBER = 50004;
+  /**
+   * <code>extend .google.protobuf.FieldOptions { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.protobuf.DescriptorProtos.FieldOptions,
+      java.lang.Boolean> typeIdInTable = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
+  public static final int SKIP_MESSAGE_IN_COMPARISON_FIELD_NUMBER = 50100;
+  /**
+   * <code>extend .google.protobuf.MessageOptions { ... }</code>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.protobuf.DescriptorProtos.MessageOptions,
+      java.lang.Boolean> skipMessageInComparison = org.jetbrains.kotlin.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Boolean.class,
+        null);
 
   public static org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
       getDescriptor() {
@@ -73,8 +97,11 @@ public final class DebugExtOptionsProtoBuf {
       "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"
+      "e.protobuf.FieldOptions\030\323\206\003 \001(\010:9\n\020type_" +
+      "id_in_table\022\035.google.protobuf.FieldOptio",
+      "ns\030\324\206\003 \001(\010:E\n\032skip_message_in_comparison" +
+      "\022\037.google.protobuf.MessageOptions\030\264\207\003 \001(" +
+      "\010B\031B\027DebugExtOptionsProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
         new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
@@ -93,6 +120,8 @@ public final class DebugExtOptionsProtoBuf {
     nameIdInTable.internalInit(descriptor.getExtensions().get(1));
     fqNameIdInTable.internalInit(descriptor.getExtensions().get(2));
     stringIdInTable.internalInit(descriptor.getExtensions().get(3));
+    typeIdInTable.internalInit(descriptor.getExtensions().get(4));
+    skipMessageInComparison.internalInit(descriptor.getExtensions().get(5));
     org.jetbrains.kotlin.protobuf.DescriptorProtos.getDescriptor();
   }
 

build-common/test/org/jetbrains/kotlin/metadata/DebugProtoBuf.java

@@ -10100,6 +10100,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isExpect
      *isInline
+     *isFun
      * </pre>
      */
     boolean hasFlags();
@@ -10116,6 +10117,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isExpect
      *isInline
+     *isFun
      * </pre>
      */
     int getFlags();
@@ -10853,6 +10855,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isExpect
      *isInline
+     *isFun
      * </pre>
      */
     public boolean hasFlags() {
@@ -10871,6 +10874,7 @@ public final class DebugProtoBuf {
      *isExternal
      *isExpect
      *isInline
+     *isFun
      * </pre>
      */
     public int getFlags() {
@@ -12242,6 +12246,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isExpect
        *isInline
+       *isFun
        * </pre>
        */
       public boolean hasFlags() {
@@ -12260,6 +12265,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isExpect
        *isInline
+       *isFun
        * </pre>
        */
       public int getFlags() {
@@ -12278,6 +12284,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isExpect
        *isInline
+       *isFun
        * </pre>
        */
       public Builder setFlags(int value) {
@@ -12299,6 +12306,7 @@ public final class DebugProtoBuf {
        *isExternal
        *isExpect
        *isInline
+       *isFun
        * </pre>
        */
       public Builder clearFlags() {
@@ -34302,192 +34310,194 @@ public final class DebugProtoBuf {
     java.lang.String[] descriptorData = {
       "\n&core/metadata/src/metadata.debug.proto" +
       "\022\035org.jetbrains.kotlin.metadata\032)core/me" +
-      "tadata/src/ext_options.debug.proto\"\035\n\013St" +
-      "ringTable\022\016\n\006string\030\001 \003(\t\"\276\002\n\022QualifiedN" +
-      "ameTable\022W\n\016qualified_name\030\001 \003(\0132?.org.j" +
-      "etbrains.kotlin.metadata.QualifiedNameTa" +
-      "ble.QualifiedName\032\316\001\n\rQualifiedName\022!\n\025p" +
-      "arent_qualified_name\030\001 \001(\005:\002-1\022\022\n\nshort_" +
-      "name\030\002 \002(\005\022[\n\004kind\030\003 \001(\0162D.org.jetbrains" +
-      ".kotlin.metadata.QualifiedNameTable.Qual",
-      "ifiedName.Kind:\007PACKAGE\")\n\004Kind\022\t\n\005CLASS" +
-      "\020\000\022\013\n\007PACKAGE\020\001\022\t\n\005LOCAL\020\002\"\226\006\n\nAnnotatio" +
-      "n\022\020\n\002id\030\001 \002(\005B\004\220\265\030\001\022D\n\010argument\030\002 \003(\01322." +
-      "org.jetbrains.kotlin.metadata.Annotation" +
-      ".Argument\032\257\005\n\010Argument\022\025\n\007name_id\030\001 \002(\005B" +
-      "\004\210\265\030\001\022G\n\005value\030\002 \002(\01328.org.jetbrains.kot" +
-      "lin.metadata.Annotation.Argument.Value\032\302" +
-      "\004\n\005Value\022K\n\004type\030\001 \001(\0162=.org.jetbrains.k" +
-      "otlin.metadata.Annotation.Argument.Value" +
-      ".Type\022\021\n\tint_value\030\002 \001(\022\022\023\n\013float_value\030",
-      "\003 \001(\002\022\024\n\014double_value\030\004 \001(\001\022\032\n\014string_va" +
-      "lue\030\005 \001(\005B\004\230\265\030\001\022\026\n\010class_id\030\006 \001(\005B\004\220\265\030\001\022" +
-      "\033\n\renum_value_id\030\007 \001(\005B\004\210\265\030\001\022=\n\nannotati" +
-      "on\030\010 \001(\0132).org.jetbrains.kotlin.metadata" +
-      ".Annotation\022O\n\rarray_element\030\t \003(\01328.org" +
+      "tadata/src/ext_options.debug.proto\"#\n\013St" +
+      "ringTable\022\016\n\006string\030\001 \003(\t:\004\240\273\030\001\"\304\002\n\022Qual" +
+      "ifiedNameTable\022W\n\016qualified_name\030\001 \003(\0132?" +
+      ".org.jetbrains.kotlin.metadata.Qualified" +
+      "NameTable.QualifiedName\032\316\001\n\rQualifiedNam" +
+      "e\022!\n\025parent_qualified_name\030\001 \001(\005:\002-1\022\022\n\n" +
+      "short_name\030\002 \002(\005\022[\n\004kind\030\003 \001(\0162D.org.jet" +
+      "brains.kotlin.metadata.QualifiedNameTabl",
+      "e.QualifiedName.Kind:\007PACKAGE\")\n\004Kind\022\t\n" +
+      "\005CLASS\020\000\022\013\n\007PACKAGE\020\001\022\t\n\005LOCAL\020\002:\004\240\273\030\001\"\226" +
+      "\006\n\nAnnotation\022\020\n\002id\030\001 \002(\005B\004\220\265\030\001\022D\n\010argum" +
+      "ent\030\002 \003(\01322.org.jetbrains.kotlin.metadat" +
+      "a.Annotation.Argument\032\257\005\n\010Argument\022\025\n\007na" +
+      "me_id\030\001 \002(\005B\004\210\265\030\001\022G\n\005value\030\002 \002(\01328.org.j" +
+      "etbrains.kotlin.metadata.Annotation.Argu" +
+      "ment.Value\032\302\004\n\005Value\022K\n\004type\030\001 \001(\0162=.org" +
       ".jetbrains.kotlin.metadata.Annotation.Ar" +
-      "gument.Value\022 \n\025array_dimension_count\030\013 " +
-      "\001(\005:\0010\022\020\n\005flags\030\n \001(\005:\0010\"\230\001\n\004Type\022\010\n\004BYT" +
-      "E\020\000\022\010\n\004CHAR\020\001\022\t\n\005SHORT\020\002\022\007\n\003INT\020\003\022\010\n\004LON" +
-      "G\020\004\022\t\n\005FLOAT\020\005\022\n\n\006DOUBLE\020\006\022\013\n\007BOOLEAN\020\007\022",
-      "\n\n\006STRING\020\010\022\t\n\005CLASS\020\t\022\010\n\004ENUM\020\n\022\016\n\nANNO" +
-      "TATION\020\013\022\t\n\005ARRAY\020\014\"\373\005\n\004Type\022>\n\010argument" +
-      "\030\002 \003(\0132,.org.jetbrains.kotlin.metadata.T" +
-      "ype.Argument\022\027\n\010nullable\030\003 \001(\010:\005false\022+\n" +
-      "\035flexible_type_capabilities_id\030\004 \001(\005B\004\230\265" +
-      "\030\001\022A\n\024flexible_upper_bound\030\005 \001(\0132#.org.j" +
-      "etbrains.kotlin.metadata.Type\022\037\n\027flexibl" +
-      "e_upper_bound_id\030\010 \001(\005\022\030\n\nclass_name\030\006 \001" +
-      "(\005B\004\220\265\030\001\022\026\n\016type_parameter\030\007 \001(\005\022!\n\023type" +
-      "_parameter_name\030\t \001(\005B\004\210\265\030\001\022\035\n\017type_alia",
-      "s_name\030\014 \001(\005B\004\220\265\030\001\0227\n\nouter_type\030\n \001(\0132#" +
-      ".org.jetbrains.kotlin.metadata.Type\022\025\n\ro" +
-      "uter_type_id\030\013 \001(\005\022=\n\020abbreviated_type\030\r" +
+      "gument.Value.Type\022\021\n\tint_value\030\002 \001(\022\022\023\n\013",
+      "float_value\030\003 \001(\002\022\024\n\014double_value\030\004 \001(\001\022" +
+      "\032\n\014string_value\030\005 \001(\005B\004\230\265\030\001\022\026\n\010class_id\030" +
+      "\006 \001(\005B\004\220\265\030\001\022\033\n\renum_value_id\030\007 \001(\005B\004\210\265\030\001" +
+      "\022=\n\nannotation\030\010 \001(\0132).org.jetbrains.kot" +
+      "lin.metadata.Annotation\022O\n\rarray_element" +
+      "\030\t \003(\01328.org.jetbrains.kotlin.metadata.A" +
+      "nnotation.Argument.Value\022 \n\025array_dimens" +
+      "ion_count\030\013 \001(\005:\0010\022\020\n\005flags\030\n \001(\005:\0010\"\230\001\n" +
+      "\004Type\022\010\n\004BYTE\020\000\022\010\n\004CHAR\020\001\022\t\n\005SHORT\020\002\022\007\n\003" +
+      "INT\020\003\022\010\n\004LONG\020\004\022\t\n\005FLOAT\020\005\022\n\n\006DOUBLE\020\006\022\013",
+      "\n\007BOOLEAN\020\007\022\n\n\006STRING\020\010\022\t\n\005CLASS\020\t\022\010\n\004EN" +
+      "UM\020\n\022\016\n\nANNOTATION\020\013\022\t\n\005ARRAY\020\014\"\223\006\n\004Type" +
+      "\022>\n\010argument\030\002 \003(\0132,.org.jetbrains.kotli" +
+      "n.metadata.Type.Argument\022\027\n\010nullable\030\003 \001" +
+      "(\010:\005false\022+\n\035flexible_type_capabilities_" +
+      "id\030\004 \001(\005B\004\230\265\030\001\022A\n\024flexible_upper_bound\030\005" +
       " \001(\0132#.org.jetbrains.kotlin.metadata.Typ" +
-      "e\022\033\n\023abbreviated_type_id\030\016 \001(\005\022\r\n\005flags\030" +
-      "\001 \001(\005\032\322\001\n\010Argument\022P\n\nprojection\030\001 \001(\01627" +
-      ".org.jetbrains.kotlin.metadata.Type.Argu" +
-      "ment.Projection:\003INV\0221\n\004type\030\002 \001(\0132#.org" +
-      ".jetbrains.kotlin.metadata.Type\022\017\n\007type_" +
-      "id\030\003 \001(\005\"0\n\nProjection\022\006\n\002IN\020\000\022\007\n\003OUT\020\001\022",
-      "\007\n\003INV\020\002\022\010\n\004STAR\020\003*\005\010d\020\310\001\"\230\002\n\rTypeParame" +
-      "ter\022\n\n\002id\030\001 \002(\005\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\022\026\n\007r" +
-      "eified\030\003 \001(\010:\005false\022L\n\010variance\030\004 \001(\01625." +
-      "org.jetbrains.kotlin.metadata.TypeParame" +
-      "ter.Variance:\003INV\0228\n\013upper_bound\030\005 \003(\0132#" +
-      ".org.jetbrains.kotlin.metadata.Type\022\032\n\016u" +
-      "pper_bound_id\030\006 \003(\005B\002\020\001\"$\n\010Variance\022\006\n\002I" +
-      "N\020\000\022\007\n\003OUT\020\001\022\007\n\003INV\020\002*\005\010d\020\350\007\"\244\007\n\005Class\022\020" +
-      "\n\005flags\030\001 \001(\005:\0016\022\025\n\007fq_name\030\003 \002(\005B\004\220\265\030\001\022" +
-      "#\n\025companion_object_name\030\004 \001(\005B\004\210\265\030\001\022D\n\016",
+      "e\022%\n\027flexible_upper_bound_id\030\010 \001(\005B\004\240\265\030\001" +
+      "\022\030\n\nclass_name\030\006 \001(\005B\004\220\265\030\001\022\026\n\016type_param" +
+      "eter\030\007 \001(\005\022!\n\023type_parameter_name\030\t \001(\005B",
+      "\004\210\265\030\001\022\035\n\017type_alias_name\030\014 \001(\005B\004\220\265\030\001\0227\n\n" +
+      "outer_type\030\n \001(\0132#.org.jetbrains.kotlin." +
+      "metadata.Type\022\033\n\router_type_id\030\013 \001(\005B\004\240\265" +
+      "\030\001\022=\n\020abbreviated_type\030\r \001(\0132#.org.jetbr" +
+      "ains.kotlin.metadata.Type\022!\n\023abbreviated" +
+      "_type_id\030\016 \001(\005B\004\240\265\030\001\022\r\n\005flags\030\001 \001(\005\032\330\001\n\010" +
+      "Argument\022P\n\nprojection\030\001 \001(\01627.org.jetbr" +
+      "ains.kotlin.metadata.Type.Argument.Proje" +
+      "ction:\003INV\0221\n\004type\030\002 \001(\0132#.org.jetbrains" +
+      ".kotlin.metadata.Type\022\025\n\007type_id\030\003 \001(\005B\004",
+      "\240\265\030\001\"0\n\nProjection\022\006\n\002IN\020\000\022\007\n\003OUT\020\001\022\007\n\003I" +
+      "NV\020\002\022\010\n\004STAR\020\003*\005\010d\020\310\001\"\234\002\n\rTypeParameter\022" +
+      "\n\n\002id\030\001 \002(\005\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\022\026\n\007reifi" +
+      "ed\030\003 \001(\010:\005false\022L\n\010variance\030\004 \001(\01625.org." +
+      "jetbrains.kotlin.metadata.TypeParameter." +
+      "Variance:\003INV\0228\n\013upper_bound\030\005 \003(\0132#.org" +
+      ".jetbrains.kotlin.metadata.Type\022\036\n\016upper" +
+      "_bound_id\030\006 \003(\005B\006\020\001\240\265\030\001\"$\n\010Variance\022\006\n\002I" +
+      "N\020\000\022\007\n\003OUT\020\001\022\007\n\003INV\020\002*\005\010d\020\350\007\"\250\007\n\005Class\022\020" +
+      "\n\005flags\030\001 \001(\005:\0016\022\025\n\007fq_name\030\003 \002(\005B\004\220\265\030\001\022",
+      "#\n\025companion_object_name\030\004 \001(\005B\004\210\265\030\001\022D\n\016" +
       "type_parameter\030\005 \003(\0132,.org.jetbrains.kot" +
       "lin.metadata.TypeParameter\0226\n\tsupertype\030" +
       "\006 \003(\0132#.org.jetbrains.kotlin.metadata.Ty" +
-      "pe\022\030\n\014supertype_id\030\002 \003(\005B\002\020\001\022!\n\021nested_c" +
-      "lass_name\030\007 \003(\005B\006\020\001\210\265\030\001\022?\n\013constructor\030\010" +
-      " \003(\0132*.org.jetbrains.kotlin.metadata.Con" +
-      "structor\0229\n\010function\030\t \003(\0132\'.org.jetbrai" +
-      "ns.kotlin.metadata.Function\0229\n\010property\030" +
-      "\n \003(\0132\'.org.jetbrains.kotlin.metadata.Pr" +
-      "operty\022<\n\ntype_alias\030\013 \003(\0132(.org.jetbrai",
-      "ns.kotlin.metadata.TypeAlias\022<\n\nenum_ent" +
-      "ry\030\r \003(\0132(.org.jetbrains.kotlin.metadata" +
-      ".EnumEntry\022\'\n\027sealed_subclass_fq_name\030\020 " +
-      "\003(\005B\006\020\001\220\265\030\001\022<\n\ntype_table\030\036 \001(\0132(.org.je" +
-      "tbrains.kotlin.metadata.TypeTable\022\033\n\023ver" +
-      "sion_requirement\030\037 \003(\005\022Y\n\031version_requir" +
-      "ement_table\030  \001(\01326.org.jetbrains.kotlin" +
-      ".metadata.VersionRequirementTable\"x\n\004Kin" +
-      "d\022\t\n\005CLASS\020\000\022\r\n\tINTERFACE\020\001\022\016\n\nENUM_CLAS" +
-      "S\020\002\022\016\n\nENUM_ENTRY\020\003\022\024\n\020ANNOTATION_CLASS\020",
-      "\004\022\n\n\006OBJECT\020\005\022\024\n\020COMPANION_OBJECT\020\006*\006\010d\020" +
-      "\270\224\001\"\335\002\n\007Package\0229\n\010function\030\003 \003(\0132\'.org." +
-      "jetbrains.kotlin.metadata.Function\0229\n\010pr" +
-      "operty\030\004 \003(\0132\'.org.jetbrains.kotlin.meta" +
-      "data.Property\022<\n\ntype_alias\030\005 \003(\0132(.org." +
-      "jetbrains.kotlin.metadata.TypeAlias\022<\n\nt" +
+      "pe\022\034\n\014supertype_id\030\002 \003(\005B\006\020\001\240\265\030\001\022!\n\021nest" +
+      "ed_class_name\030\007 \003(\005B\006\020\001\210\265\030\001\022?\n\013construct" +
+      "or\030\010 \003(\0132*.org.jetbrains.kotlin.metadata" +
+      ".Constructor\0229\n\010function\030\t \003(\0132\'.org.jet" +
+      "brains.kotlin.metadata.Function\0229\n\010prope" +
+      "rty\030\n \003(\0132\'.org.jetbrains.kotlin.metadat",
+      "a.Property\022<\n\ntype_alias\030\013 \003(\0132(.org.jet" +
+      "brains.kotlin.metadata.TypeAlias\022<\n\nenum" +
+      "_entry\030\r \003(\0132(.org.jetbrains.kotlin.meta" +
+      "data.EnumEntry\022\'\n\027sealed_subclass_fq_nam" +
+      "e\030\020 \003(\005B\006\020\001\220\265\030\001\022<\n\ntype_table\030\036 \001(\0132(.or" +
+      "g.jetbrains.kotlin.metadata.TypeTable\022\033\n" +
+      "\023version_requirement\030\037 \003(\005\022Y\n\031version_re" +
+      "quirement_table\030  \001(\01326.org.jetbrains.ko" +
+      "tlin.metadata.VersionRequirementTable\"x\n" +
+      "\004Kind\022\t\n\005CLASS\020\000\022\r\n\tINTERFACE\020\001\022\016\n\nENUM_",
+      "CLASS\020\002\022\016\n\nENUM_ENTRY\020\003\022\024\n\020ANNOTATION_CL" +
+      "ASS\020\004\022\n\n\006OBJECT\020\005\022\024\n\020COMPANION_OBJECT\020\006*" +
+      "\006\010d\020\270\224\001\"\335\002\n\007Package\0229\n\010function\030\003 \003(\0132\'." +
+      "org.jetbrains.kotlin.metadata.Function\0229" +
+      "\n\010property\030\004 \003(\0132\'.org.jetbrains.kotlin." +
+      "metadata.Property\022<\n\ntype_alias\030\005 \003(\0132(." +
+      "org.jetbrains.kotlin.metadata.TypeAlias\022" +
+      "<\n\ntype_table\030\036 \001(\0132(.org.jetbrains.kotl" +
+      "in.metadata.TypeTable\022Y\n\031version_require" +
+      "ment_table\030  \001(\01326.org.jetbrains.kotlin.",
+      "metadata.VersionRequirementTable*\005\010d\020\310\001\"" +
+      "`\n\tTypeTable\0221\n\004type\030\001 \003(\0132#.org.jetbrai" +
+      "ns.kotlin.metadata.Type\022\032\n\016first_nullabl" +
+      "e\030\002 \001(\005:\002-1:\004\240\273\030\001\"\214\001\n\013Constructor\022\020\n\005fla" +
+      "gs\030\001 \001(\005:\0016\022F\n\017value_parameter\030\002 \003(\0132-.o" +
+      "rg.jetbrains.kotlin.metadata.ValueParame" +
+      "ter\022\033\n\023version_requirement\030\037 \003(\005*\006\010d\020\270\224\001" +
+      "\"\246\004\n\010Function\022\020\n\005flags\030\t \001(\005:\0016\022\024\n\told_f" +
+      "lags\030\001 \001(\005:\0016\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\0228\n\013ret" +
+      "urn_type\030\003 \001(\0132#.org.jetbrains.kotlin.me",
+      "tadata.Type\022\034\n\016return_type_id\030\007 \001(\005B\004\240\265\030" +
+      "\001\022D\n\016type_parameter\030\004 \003(\0132,.org.jetbrain" +
+      "s.kotlin.metadata.TypeParameter\022:\n\rrecei" +
+      "ver_type\030\005 \001(\0132#.org.jetbrains.kotlin.me" +
+      "tadata.Type\022\036\n\020receiver_type_id\030\010 \001(\005B\004\240" +
+      "\265\030\001\022F\n\017value_parameter\030\006 \003(\0132-.org.jetbr" +
+      "ains.kotlin.metadata.ValueParameter\022<\n\nt" +
       "ype_table\030\036 \001(\0132(.org.jetbrains.kotlin.m" +
-      "etadata.TypeTable\022Y\n\031version_requirement" +
-      "_table\030  \001(\01326.org.jetbrains.kotlin.meta" +
-      "data.VersionRequirementTable*\005\010d\020\310\001\"Z\n\tT",
-      "ypeTable\0221\n\004type\030\001 \003(\0132#.org.jetbrains.k" +
-      "otlin.metadata.Type\022\032\n\016first_nullable\030\002 " +
-      "\001(\005:\002-1\"\214\001\n\013Constructor\022\020\n\005flags\030\001 \001(\005:\001" +
-      "6\022F\n\017value_parameter\030\002 \003(\0132-.org.jetbrai" +
-      "ns.kotlin.metadata.ValueParameter\022\033\n\023ver" +
-      "sion_requirement\030\037 \003(\005*\006\010d\020\270\224\001\"\232\004\n\010Funct" +
-      "ion\022\020\n\005flags\030\t \001(\005:\0016\022\024\n\told_flags\030\001 \001(\005" +
-      ":\0016\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\0228\n\013return_type\030\003" +
+      "etadata.TypeTable\022\033\n\023version_requirement" +
+      "\030\037 \003(\005\0229\n\010contract\030  \001(\0132\'.org.jetbrains",
+      ".kotlin.metadata.Contract*\006\010d\020\270\224\001\"\345\003\n\010Pr" +
+      "operty\022\022\n\005flags\030\013 \001(\005:\003518\022\027\n\told_flags\030" +
+      "\001 \001(\005:\0042054\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\0228\n\013retur" +
+      "n_type\030\003 \001(\0132#.org.jetbrains.kotlin.meta" +
+      "data.Type\022\034\n\016return_type_id\030\t \001(\005B\004\240\265\030\001\022" +
+      "D\n\016type_parameter\030\004 \003(\0132,.org.jetbrains." +
+      "kotlin.metadata.TypeParameter\022:\n\rreceive" +
+      "r_type\030\005 \001(\0132#.org.jetbrains.kotlin.meta" +
+      "data.Type\022\036\n\020receiver_type_id\030\n \001(\005B\004\240\265\030" +
+      "\001\022M\n\026setter_value_parameter\030\006 \001(\0132-.org.",
+      "jetbrains.kotlin.metadata.ValueParameter" +
+      "\022\024\n\014getter_flags\030\007 \001(\005\022\024\n\014setter_flags\030\010" +
+      " \001(\005\022\033\n\023version_requirement\030\037 \003(\005*\006\010d\020\270\224" +
+      "\001\"\357\001\n\016ValueParameter\022\020\n\005flags\030\001 \001(\005:\0010\022\022" +
+      "\n\004name\030\002 \002(\005B\004\210\265\030\001\0221\n\004type\030\003 \001(\0132#.org.j" +
+      "etbrains.kotlin.metadata.Type\022\025\n\007type_id" +
+      "\030\005 \001(\005B\004\240\265\030\001\022@\n\023vararg_element_type\030\004 \001(" +
+      "\0132#.org.jetbrains.kotlin.metadata.Type\022$" +
+      "\n\026vararg_element_type_id\030\006 \001(\005B\004\240\265\030\001*\005\010d" +
+      "\020\310\001\"\226\003\n\tTypeAlias\022\020\n\005flags\030\001 \001(\005:\0016\022\022\n\004n",
+      "ame\030\002 \002(\005B\004\210\265\030\001\022D\n\016type_parameter\030\003 \003(\0132" +
+      ",.org.jetbrains.kotlin.metadata.TypePara" +
+      "meter\022<\n\017underlying_type\030\004 \001(\0132#.org.jet" +
+      "brains.kotlin.metadata.Type\022 \n\022underlyin" +
+      "g_type_id\030\005 \001(\005B\004\240\265\030\001\022:\n\rexpanded_type\030\006" +
       " \001(\0132#.org.jetbrains.kotlin.metadata.Typ" +
-      "e\022\026\n\016return_type_id\030\007 \001(\005\022D\n\016type_parame",
-      "ter\030\004 \003(\0132,.org.jetbrains.kotlin.metadat" +
-      "a.TypeParameter\022:\n\rreceiver_type\030\005 \001(\0132#" +
-      ".org.jetbrains.kotlin.metadata.Type\022\030\n\020r" +
-      "eceiver_type_id\030\010 \001(\005\022F\n\017value_parameter" +
-      "\030\006 \003(\0132-.org.jetbrains.kotlin.metadata.V" +
-      "alueParameter\022<\n\ntype_table\030\036 \001(\0132(.org." +
-      "jetbrains.kotlin.metadata.TypeTable\022\033\n\023v" +
-      "ersion_requirement\030\037 \003(\005\0229\n\010contract\030  \001" +
-      "(\0132\'.org.jetbrains.kotlin.metadata.Contr" +
-      "act*\006\010d\020\270\224\001\"\331\003\n\010Property\022\022\n\005flags\030\013 \001(\005:",
-      "\003518\022\027\n\told_flags\030\001 \001(\005:\0042054\022\022\n\004name\030\002 " +
-      "\002(\005B\004\210\265\030\001\0228\n\013return_type\030\003 \001(\0132#.org.jet" +
-      "brains.kotlin.metadata.Type\022\026\n\016return_ty" +
-      "pe_id\030\t \001(\005\022D\n\016type_parameter\030\004 \003(\0132,.or" +
-      "g.jetbrains.kotlin.metadata.TypeParamete" +
-      "r\022:\n\rreceiver_type\030\005 \001(\0132#.org.jetbrains" +
-      ".kotlin.metadata.Type\022\030\n\020receiver_type_i" +
-      "d\030\n \001(\005\022M\n\026setter_value_parameter\030\006 \001(\0132" +
-      "-.org.jetbrains.kotlin.metadata.ValuePar" +
-      "ameter\022\024\n\014getter_flags\030\007 \001(\005\022\024\n\014setter_f",
-      "lags\030\010 \001(\005\022\033\n\023version_requirement\030\037 \003(\005*" +
-      "\006\010d\020\270\224\001\"\343\001\n\016ValueParameter\022\020\n\005flags\030\001 \001(" +
-      "\005:\0010\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\0221\n\004type\030\003 \001(\0132#" +
-      ".org.jetbrains.kotlin.metadata.Type\022\017\n\007t" +
-      "ype_id\030\005 \001(\005\022@\n\023vararg_element_type\030\004 \001(" +
-      "\0132#.org.jetbrains.kotlin.metadata.Type\022\036" +
-      "\n\026vararg_element_type_id\030\006 \001(\005*\005\010d\020\310\001\"\212\003" +
-      "\n\tTypeAlias\022\020\n\005flags\030\001 \001(\005:\0016\022\022\n\004name\030\002 " +
-      "\002(\005B\004\210\265\030\001\022D\n\016type_parameter\030\003 \003(\0132,.org." +
-      "jetbrains.kotlin.metadata.TypeParameter\022",
-      "<\n\017underlying_type\030\004 \001(\0132#.org.jetbrains" +
-      ".kotlin.metadata.Type\022\032\n\022underlying_type" +
-      "_id\030\005 \001(\005\022:\n\rexpanded_type\030\006 \001(\0132#.org.j" +
-      "etbrains.kotlin.metadata.Type\022\030\n\020expande" +
-      "d_type_id\030\007 \001(\005\022=\n\nannotation\030\010 \003(\0132).or" +
-      "g.jetbrains.kotlin.metadata.Annotation\022\033" +
-      "\n\023version_requirement\030\037 \003(\005*\005\010d\020\310\001\"&\n\tEn" +
-      "umEntry\022\022\n\004name\030\001 \001(\005B\004\210\265\030\001*\005\010d\020\310\001\"\225\003\n\022V" +
-      "ersionRequirement\022\017\n\007version\030\001 \001(\005\022\024\n\014ve" +
-      "rsion_full\030\002 \001(\005\022M\n\005level\030\003 \001(\01627.org.je",
-      "tbrains.kotlin.metadata.VersionRequireme" +
-      "nt.Level:\005ERROR\022\022\n\nerror_code\030\004 \001(\005\022\025\n\007m" +
-      "essage\030\005 \001(\005B\004\230\265\030\001\022e\n\014version_kind\030\006 \001(\016" +
-      "2=.org.jetbrains.kotlin.metadata.Version" +
-      "Requirement.VersionKind:\020LANGUAGE_VERSIO" +
-      "N\"+\n\005Level\022\013\n\007WARNING\020\000\022\t\n\005ERROR\020\001\022\n\n\006HI" +
-      "DDEN\020\002\"J\n\013VersionKind\022\024\n\020LANGUAGE_VERSIO" +
-      "N\020\000\022\024\n\020COMPILER_VERSION\020\001\022\017\n\013API_VERSION" +
-      "\020\002\"a\n\027VersionRequirementTable\022F\n\013require" +
-      "ment\030\001 \003(\01321.org.jetbrains.kotlin.metada",
-      "ta.VersionRequirement\"\217\002\n\017PackageFragmen" +
-      "t\022;\n\007strings\030\001 \001(\0132*.org.jetbrains.kotli" +
-      "n.metadata.StringTable\022J\n\017qualified_name" +
-      "s\030\002 \001(\01321.org.jetbrains.kotlin.metadata." +
-      "QualifiedNameTable\0227\n\007package\030\003 \001(\0132&.or" +
-      "g.jetbrains.kotlin.metadata.Package\0223\n\005c" +
-      "lass\030\004 \003(\0132$.org.jetbrains.kotlin.metada" +
-      "ta.Class*\005\010d\020\310\001\"A\n\010Contract\0225\n\006effect\030\001 " +
-      "\003(\0132%.org.jetbrains.kotlin.metadata.Effe" +
-      "ct\"\306\003\n\006Effect\022E\n\013effect_type\030\001 \001(\01620.org",
-      ".jetbrains.kotlin.metadata.Effect.Effect" +
-      "Type\022N\n\033effect_constructor_argument\030\002 \003(" +
-      "\0132).org.jetbrains.kotlin.metadata.Expres" +
-      "sion\022S\n conclusion_of_conditional_effect" +
-      "\030\003 \001(\0132).org.jetbrains.kotlin.metadata.E" +
-      "xpression\022B\n\004kind\030\004 \001(\01624.org.jetbrains." +
-      "kotlin.metadata.Effect.InvocationKind\"C\n" +
-      "\nEffectType\022\024\n\020RETURNS_CONSTANT\020\000\022\t\n\005CAL" +
-      "LS\020\001\022\024\n\020RETURNS_NOT_NULL\020\002\"G\n\016Invocation" +
-      "Kind\022\020\n\014AT_MOST_ONCE\020\000\022\020\n\014EXACTLY_ONCE\020\001",
-      "\022\021\n\rAT_LEAST_ONCE\020\002\"\237\003\n\nExpression\022\020\n\005fl" +
-      "ags\030\001 \001(\005:\0010\022!\n\031value_parameter_referenc" +
-      "e\030\002 \001(\005\022O\n\016constant_value\030\003 \001(\01627.org.je" +
-      "tbrains.kotlin.metadata.Expression.Const" +
-      "antValue\022=\n\020is_instance_type\030\004 \001(\0132#.org" +
-      ".jetbrains.kotlin.metadata.Type\022\033\n\023is_in" +
-      "stance_type_id\030\005 \001(\005\022?\n\014and_argument\030\006 \003" +
-      "(\0132).org.jetbrains.kotlin.metadata.Expre" +
-      "ssion\022>\n\013or_argument\030\007 \003(\0132).org.jetbrai" +
-      "ns.kotlin.metadata.Expression\".\n\rConstan",
-      "tValue\022\010\n\004TRUE\020\000\022\t\n\005FALSE\020\001\022\010\n\004NULL\020\002*9\n" +
-      "\010Modality\022\t\n\005FINAL\020\000\022\010\n\004OPEN\020\001\022\014\n\010ABSTRA" +
-      "CT\020\002\022\n\n\006SEALED\020\003*b\n\nVisibility\022\014\n\010INTERN" +
-      "AL\020\000\022\013\n\007PRIVATE\020\001\022\r\n\tPROTECTED\020\002\022\n\n\006PUBL" +
-      "IC\020\003\022\023\n\017PRIVATE_TO_THIS\020\004\022\t\n\005LOCAL\020\005*Q\n\n" +
-      "MemberKind\022\017\n\013DECLARATION\020\000\022\021\n\rFAKE_OVER" +
-      "RIDE\020\001\022\016\n\nDELEGATION\020\002\022\017\n\013SYNTHESIZED\020\003B" +
-      "\017B\rDebugProtoBuf"
+      "e\022\036\n\020expanded_type_id\030\007 \001(\005B\004\240\265\030\001\022=\n\nann" +
+      "otation\030\010 \003(\0132).org.jetbrains.kotlin.met" +
+      "adata.Annotation\022\033\n\023version_requirement\030" +
+      "\037 \003(\005*\005\010d\020\310\001\"&\n\tEnumEntry\022\022\n\004name\030\001 \001(\005B",
+      "\004\210\265\030\001*\005\010d\020\310\001\"\225\003\n\022VersionRequirement\022\017\n\007v" +
+      "ersion\030\001 \001(\005\022\024\n\014version_full\030\002 \001(\005\022M\n\005le" +
+      "vel\030\003 \001(\01627.org.jetbrains.kotlin.metadat" +
+      "a.VersionRequirement.Level:\005ERROR\022\022\n\nerr" +
+      "or_code\030\004 \001(\005\022\025\n\007message\030\005 \001(\005B\004\230\265\030\001\022e\n\014" +
+      "version_kind\030\006 \001(\0162=.org.jetbrains.kotli" +
+      "n.metadata.VersionRequirement.VersionKin" +
+      "d:\020LANGUAGE_VERSION\"+\n\005Level\022\013\n\007WARNING\020" +
+      "\000\022\t\n\005ERROR\020\001\022\n\n\006HIDDEN\020\002\"J\n\013VersionKind\022" +
+      "\024\n\020LANGUAGE_VERSION\020\000\022\024\n\020COMPILER_VERSIO",
+      "N\020\001\022\017\n\013API_VERSION\020\002\"a\n\027VersionRequireme" +
+      "ntTable\022F\n\013requirement\030\001 \003(\01321.org.jetbr" +
+      "ains.kotlin.metadata.VersionRequirement\"" +
+      "\217\002\n\017PackageFragment\022;\n\007strings\030\001 \001(\0132*.o" +
+      "rg.jetbrains.kotlin.metadata.StringTable" +
+      "\022J\n\017qualified_names\030\002 \001(\01321.org.jetbrain" +
+      "s.kotlin.metadata.QualifiedNameTable\0227\n\007" +
+      "package\030\003 \001(\0132&.org.jetbrains.kotlin.met" +
+      "adata.Package\0223\n\005class\030\004 \003(\0132$.org.jetbr" +
+      "ains.kotlin.metadata.Class*\005\010d\020\310\001\"A\n\010Con",
+      "tract\0225\n\006effect\030\001 \003(\0132%.org.jetbrains.ko" +
+      "tlin.metadata.Effect\"\306\003\n\006Effect\022E\n\013effec" +
+      "t_type\030\001 \001(\01620.org.jetbrains.kotlin.meta" +
+      "data.Effect.EffectType\022N\n\033effect_constru" +
+      "ctor_argument\030\002 \003(\0132).org.jetbrains.kotl" +
+      "in.metadata.Expression\022S\n conclusion_of_" +
+      "conditional_effect\030\003 \001(\0132).org.jetbrains" +
+      ".kotlin.metadata.Expression\022B\n\004kind\030\004 \001(" +
+      "\01624.org.jetbrains.kotlin.metadata.Effect" +
+      ".InvocationKind\"C\n\nEffectType\022\024\n\020RETURNS",
+      "_CONSTANT\020\000\022\t\n\005CALLS\020\001\022\024\n\020RETURNS_NOT_NU" +
+      "LL\020\002\"G\n\016InvocationKind\022\020\n\014AT_MOST_ONCE\020\000" +
+      "\022\020\n\014EXACTLY_ONCE\020\001\022\021\n\rAT_LEAST_ONCE\020\002\"\245\003" +
+      "\n\nExpression\022\020\n\005flags\030\001 \001(\005:\0010\022!\n\031value_" +
+      "parameter_reference\030\002 \001(\005\022O\n\016constant_va" +
+      "lue\030\003 \001(\01627.org.jetbrains.kotlin.metadat" +
+      "a.Expression.ConstantValue\022=\n\020is_instanc" +
+      "e_type\030\004 \001(\0132#.org.jetbrains.kotlin.meta" +
+      "data.Type\022!\n\023is_instance_type_id\030\005 \001(\005B\004" +
+      "\240\265\030\001\022?\n\014and_argument\030\006 \003(\0132).org.jetbrai",
+      "ns.kotlin.metadata.Expression\022>\n\013or_argu" +
+      "ment\030\007 \003(\0132).org.jetbrains.kotlin.metada" +
+      "ta.Expression\".\n\rConstantValue\022\010\n\004TRUE\020\000" +
+      "\022\t\n\005FALSE\020\001\022\010\n\004NULL\020\002*9\n\010Modality\022\t\n\005FIN" +
+      "AL\020\000\022\010\n\004OPEN\020\001\022\014\n\010ABSTRACT\020\002\022\n\n\006SEALED\020\003" +
+      "*b\n\nVisibility\022\014\n\010INTERNAL\020\000\022\013\n\007PRIVATE\020" +
+      "\001\022\r\n\tPROTECTED\020\002\022\n\n\006PUBLIC\020\003\022\023\n\017PRIVATE_" +
+      "TO_THIS\020\004\022\t\n\005LOCAL\020\005*Q\n\nMemberKind\022\017\n\013DE" +
+      "CLARATION\020\000\022\021\n\rFAKE_OVERRIDE\020\001\022\016\n\nDELEGA" +
+      "TION\020\002\022\017\n\013SYNTHESIZED\020\003B\017B\rDebugProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
         new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
@@ -34648,26 +34658,44 @@ public final class DebugProtoBuf {
         new java.lang.String[] { "Flags", "ValueParameterReference", "ConstantValue", "IsInstanceType", "IsInstanceTypeId", "AndArgument", "OrArgument", });
     org.jetbrains.kotlin.protobuf.ExtensionRegistry registry =
         org.jetbrains.kotlin.protobuf.ExtensionRegistry.newInstance();
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.skipMessageInComparison);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.skipMessageInComparison);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.stringIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.stringIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.fqNameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.skipMessageInComparison);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.nameIdInTable);
     registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.stringIdInTable);
+    registry.add(org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.typeIdInTable);
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
         .internalUpdateFileDescriptor(descriptor, registry);
     org.jetbrains.kotlin.metadata.DebugExtOptionsProtoBuf.getDescriptor();

build.gradle.kts

@@ -3,18 +3,16 @@ import org.gradle.plugins.ide.idea.model.IdeaModel
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import proguard.gradle.ProGuardTask
-import org.gradle.kotlin.dsl.*
 
 buildscript {
-    extra["defaultSnapshotVersion"] = "1.3-SNAPSHOT"
+    extra["defaultSnapshotVersion"] = "1.4-SNAPSHOT"
+    val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    // when updating please also update JPS artifacts configuration: https://jetbrains.quip.com/zzGUAYSJ6gv3/JPS-Build-update-bootstrap
-    kotlinBootstrapFrom(BootstrapOption.TeamCity("1.3.50-dev-526", onlySuccessBootstrap = false))
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap("1.4.0-dev-1818", cacheRedirectorEnabled))
 
     repositories {
         bootstrapKotlinRepo?.let(::maven)
 
-        val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/plugins.gradle.org/m2")
         } else {
@@ -30,6 +28,7 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
         classpath("com.gradle.publish:plugin-publish-plugin:0.9.7")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath("net.sf.proguard:proguard-gradle:6.1.0")
@@ -37,8 +36,11 @@ buildscript {
     }
 }
 
+if (kotlinBuildProperties.buildScanServer != null) {
+    apply(from = "gradle/buildScanUserData.gradle")
+}
+
 plugins {
-    `build-scan`
     idea
     id("jps-compatible")
     id("org.jetbrains.gradle.plugin.idea-ext")
@@ -53,10 +55,10 @@ pill {
     )
 }
 
-buildScan {
-    setTermsOfServiceUrl("https://gradle.com/terms-of-service")
-    setTermsOfServiceAgree("yes")
-}
+val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
+val includeStdlibJsIr by extra(
+    findProperty("include.stdlib.js.ir")?.let { it.toString().toBoolean() } ?: isTeamcityBuild
+)
 
 val configuredJdks: List<JdkId> =
     getConfiguredJdks().also {
@@ -69,7 +71,7 @@ val defaultSnapshotVersion: String by extra
 val buildNumber by extra(findProperty("build.number")?.toString() ?: defaultSnapshotVersion)
 val kotlinVersion by extra(findProperty("deployVersion")?.toString() ?: buildNumber)
 
-val kotlinLanguageVersion by extra("1.3")
+val kotlinLanguageVersion by extra("1.4")
 
 allprojects {
     group = "org.jetbrains.kotlin"
@@ -115,8 +117,13 @@ extra["isSonatypeRelease"] = false
 // Work-around necessary to avoid setting null javaHome. Will be removed after support of lazy task configuration
 val jdkNotFoundConst = "JDK NOT FOUND"
 
-extra["JDK_16"] = jdkPath("1.6")
-extra["JDK_17"] = jdkPath("1.7")
+if (isTeamcityBuild) {
+    extra["JDK_16"] = jdkPath("1.6")
+    extra["JDK_17"] = jdkPath("1.7")
+} else {
+    extra["JDK_16"] = jdkPath("1.6", "1.8")
+    extra["JDK_17"] = jdkPath("1.7", "1.8")
+}
 extra["JDK_18"] = jdkPath("1.8")
 extra["JDK_9"] = jdkPath("9")
 extra["JDK_10"] = jdkPath("10")
@@ -144,7 +151,7 @@ rootProject.apply {
     from(rootProject.file("gradle/jps.gradle.kts"))
 }
 
-IdeVersionConfigurator.setCurrentIde(this)
+IdeVersionConfigurator.setCurrentIde(project)
 
 extra["versions.protobuf"] = "2.6.1"
 extra["versions.javax.inject"] = "1"
@@ -166,15 +173,16 @@ extra["versions.org.springframework"] = "4.2.0.RELEASE"
 extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
+extra["versions.completion-ranking-kotlin"] = "0.1.2"
+extra["versions.r8"] = "1.5.70"
 
 // NOTE: please, also change KTOR_NAME in pathUtil.kt and all versions in corresponding jar names in daemon tests.
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.3.50-dev-11052"
+    extra["versions.kotlin-native"] = "1.4-dev-14579"
 }
 
-val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
 val effectSystemEnabled by extra(project.getBooleanProperty("kotlin.compiler.effectSystemEnabled") ?: false)
 val newInferenceEnabled by extra(project.getBooleanProperty("kotlin.compiler.newInferenceEnabled") ?: false)
@@ -190,11 +198,11 @@ extra["IntellijCoreDependencies"] =
         "jdom",
         "jna",
         "log4j",
-        "picocontainer",
+        if (Platform[201].orHigher()) null else "picocontainer",
         "snappy-in-java",
         "streamex",
         "trove4j"
-    )
+    ).filterNotNull()
 
 
 extra["compilerModules"] = arrayOf(
@@ -212,10 +220,13 @@ extra["compilerModules"] = arrayOf(
     ":compiler:ir.backend.common",
     ":compiler:backend.jvm",
     ":compiler:backend.js",
+    ":compiler:backend.wasm",
     ":compiler:ir.serialization.common",
     ":compiler:ir.serialization.js",
+    ":compiler:ir.serialization.jvm",
     ":kotlin-util-io",
     ":kotlin-util-klib",
+    ":kotlin-util-klib-metadata",
     ":compiler:backend-common",
     ":compiler:backend",
     ":compiler:plugin-api",
@@ -229,12 +240,14 @@ extra["compilerModules"] = arrayOf(
     ":js:js.frontend",
     ":js:js.translator",
     ":js:js.dce",
+    ":native:frontend.native",
     ":compiler",
     ":kotlin-build-common",
     ":core:metadata",
     ":core:metadata.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
+    ":core:descriptors.runtime",
     ":core:deserialization",
     ":core:util.runtime",
     ":core:type-system",
@@ -242,17 +255,19 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:resolve",
     ":compiler:fir:tree",
     ":compiler:fir:psi2fir",
+    ":compiler:fir:lightTree",
     ":compiler:fir:fir2ir",
-    ":compiler:fir:java"
+    ":compiler:fir:java",
+    ":compiler:fir:jvm"
 )
 
 val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib-js",
-    // Local builds are disabled at the request of the lib team
-    // TODO: Enable when tests are fixed
-    ":kotlin-stdlib-js-ir".takeIf { isTeamcityBuild },
+    // Exclude JS IR from core libs because it depends on local compiler build, which
+    // in turn depends on local JVM stdlib. It slows down library testing.
+    ":kotlin-stdlib-js-ir".takeIf { includeStdlibJsIr },
     ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
     ":kotlin-test:kotlin-test-common",
@@ -260,8 +275,9 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-test:kotlin-test-junit",
     ":kotlin-test:kotlin-test-junit5",
     ":kotlin-test:kotlin-test-testng",
-    ":kotlin-test:kotlin-test-js",
-    ":kotlin-reflect"
+    ":kotlin-test:kotlin-test-js".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
+    ":kotlin-reflect",
+    ":kotlin-coroutines-experimental-compat"
 )
 
 val gradlePluginProjects = listOf(
@@ -324,6 +340,8 @@ allprojects {
         maven(intellijRepo)
         maven("https://dl.bintray.com/kotlin/ktor")
         maven("https://kotlin.bintray.com/kotlin-dependencies")
+        maven("https://jetbrains.bintray.com/intellij-third-party-dependencies")
+        maven("https://dl.google.com/dl/android/maven2")
         bootstrapKotlinRepo?.let(::maven)
         internalKotlinRepo?.let(::maven)
     }
@@ -332,10 +350,9 @@ allprojects {
 
     val commonCompilerArgs = listOfNotNull(
         "-Xuse-experimental=kotlin.Experimental",
-        "-Xallow-kotlin-package",
         "-Xread-deserialized-contracts",
         "-Xjvm-default=compatibility",
-        "-Xprogressive".takeIf { hasProperty("test.progressive.mode") } // TODO: change to "-progressive" after bootstrap
+        "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
@@ -364,11 +381,23 @@ allprojects {
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
     }
 
-    task("listArchives") { listConfigurationContents("archives") }
+    tasks.withType<AbstractArchiveTask> {
+        isPreserveFileTimestamps = false
+        isReproducibleFileOrder = true
+    }
 
-    task("listRuntimeJar") { listConfigurationContents("runtimeJar") }
+    tasks.withType<Test> {
+        outputs.cacheIf { false }
+        // https://youtrack.jetbrains.com/issue/KT-37089
+    }
 
-    task("listDistJar") { listConfigurationContents("distJar") }
+    tasks {
+        register("listArchives") { listConfigurationContents("archives") }
+
+        register("listRuntimeJar") { listConfigurationContents("runtimeJar") }
+
+        register("listDistJar") { listConfigurationContents("distJar") }
+    }
 
     afterEvaluate {
         if (javaHome != defaultJavaHome || jvmTarget != defaultJvmTarget) {
@@ -386,10 +415,12 @@ allprojects {
         } 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") } }
+            tasks {
+                register("printCompileClasspath") { doFirst { javaConvention.sourceSets["main"].compileClasspath.printClassPath("compile") } }
+                register("printRuntimeClasspath") { doFirst { javaConvention.sourceSets["main"].runtimeClasspath.printClassPath("runtime") } }
+                register("printTestCompileClasspath") { doFirst { javaConvention.sourceSets["test"].compileClasspath.printClassPath("test compile") } }
+                register("printTestRuntimeClasspath") { doFirst { javaConvention.sourceSets["test"].runtimeClasspath.printClassPath("test runtime") } }
+            }
         }
 
         run configureCompilerClasspath@{
@@ -397,6 +428,9 @@ allprojects {
             configurations.findByName("kotlinCompilerClasspath")?.let {
                 dependencies.add(it.name, files(bootstrapCompilerClasspath))
             }
+
+            configurations.findByName("kotlinCompilerPluginClasspath")
+                ?.exclude("org.jetbrains.kotlin", "kotlin-scripting-compiler-embeddable")
         }
 
         // Aggregate task for build related checks
@@ -417,13 +451,13 @@ gradle.taskGraph.whenReady {
         }
     } else {
         logger.warn("Local build profile is active (IC is on, proguard is off). Use -Pteamcity=true to reproduce TC build")
-        for (task in allTasks) {
-            when (task) {
-                // todo: remove when Gradle 4.10+ is used (Java IC on by default)
-                is JavaCompile -> task.options.isIncremental = true
-                is org.gradle.jvm.tasks.Jar -> task.entryCompression = ZipEntryCompression.STORED
-            }
-        }
+    }
+
+    allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
+        task.entryCompression = if (kotlinBuildProperties.jarCompression)
+            ZipEntryCompression.DEFLATED
+        else
+            ZipEntryCompression.STORED
     }
 }
 
@@ -443,29 +477,29 @@ val ideaPlugin by task<Task> {
 }
 
 tasks {
-    create("clean") {
+    register("clean") {
         doLast {
             delete("$buildDir/repo")
             delete(distDir)
         }
     }
 
-    create("cleanupArtifacts") {
+    register("cleanupArtifacts") {
         doLast {
             delete(artifactsDir)
         }
     }
 
     listOf("clean", "assemble", "install", "dist").forEach { taskName ->
-        create("coreLibs${taskName.capitalize()}") {
+        register("coreLibs${taskName.capitalize()}") {
             coreLibProjects.forEach { projectName -> dependsOn("$projectName:$taskName") }
         }
     }
 
-    create("coreLibsTest") {
+    register("coreLibsTest") {
         (coreLibProjects + listOf(
             ":kotlin-stdlib:samples",
-            ":kotlin-test:kotlin-test-js:kotlin-test-js-it",
+            ":kotlin-test:kotlin-test-js:kotlin-test-js-it".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlinx-metadata-jvm",
             ":tools:binary-compatibility-validator"
         )).forEach {
@@ -473,99 +507,141 @@ tasks {
         }
     }
 
-    create("gradlePluginTest") {
+    register("gradlePluginTest") {
         gradlePluginProjects.forEach {
             dependsOn("$it:check")
         }
     }
 
-    create("gradlePluginIntegrationTest") {
+    register("gradlePluginIntegrationTest") {
         dependsOn(":kotlin-gradle-plugin-integration-tests:check")
     }
 
-    create("jvmCompilerTest") {
+    register("jvmCompilerTest") {
         dependsOn("dist")
         dependsOn(
             ":compiler:test",
             ":compiler:container:test",
             ":compiler:tests-java8:test",
-            ":compiler:tests-spec:remoteRunTests"
+            ":compiler:tests-spec:remoteRunTests",
+            ":compiler:tests-against-klib:test"
         )
         dependsOn(":plugins:jvm-abi-gen:test")
     }
 
-    create("jsCompilerTest") {
+    register("jvmCompilerIntegrationTest") {
+        dependsOn(
+            ":kotlin-compiler-embeddable:test",
+            ":kotlin-compiler-client-embeddable:test"
+        )
+    }
+
+    register("jsCompilerTest") {
         dependsOn(":js:js.tests:test")
         dependsOn(":js:js.tests:runMocha")
     }
 
-    create("firCompilerTest") {
+    register("wasmCompilerTest") {
+//  TODO: fix once
+//        dependsOn(":js:js.tests:wasmTest")
+    }
+
+    register("firCompilerTest") {
         dependsOn(":compiler:fir:psi2fir:test")
         dependsOn(":compiler:fir:resolve:test")
         dependsOn(":compiler:fir:fir2ir:test")
         dependsOn(":compiler:fir:lightTree:test")
     }
 
-    create("scriptingTest") {
+    register("firAllTest") {
+        dependsOn(
+            ":compiler:fir:psi2fir:test",
+            ":compiler:fir:lightTree:test",
+            ":compiler:fir:resolve:test",
+            ":compiler:fir:fir2ir:test",
+            ":idea:firTest"
+        )
+    }
+
+    register("compilerFrontendVisualizerTest") {
+        dependsOn("compiler:visualizer:test")
+    }
+
+    register("scriptingTest") {
         dependsOn("dist")
         dependsOn(":kotlin-script-util:test")
         dependsOn(":kotlin-scripting-compiler:test")
+        dependsOn(":kotlin-scripting-common:test")
+        dependsOn(":kotlin-scripting-jvm:test")
         dependsOn(":kotlin-scripting-jvm-host-test:test")
+        dependsOn(":kotlin-scripting-dependencies:test")
+        dependsOn(":kotlin-scripting-dependencies-maven:test")
         dependsOn(":kotlin-scripting-jsr223-test:test")
-        dependsOn(":kotlin-scripting-jvm-host-test:embeddableTest")
+        // see comments on the task in kotlin-scripting-jvm-host-test
+//        dependsOn(":kotlin-scripting-jvm-host-test:embeddableTest")
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
     }
 
-    create("compilerTest") {
+    register("compilerTest") {
         dependsOn("jvmCompilerTest")
         dependsOn("jsCompilerTest")
+        dependsOn("wasmCompilerTest")
         dependsOn("firCompilerTest")
 
         dependsOn("scriptingTest")
         dependsOn(":kotlin-build-common:test")
         dependsOn(":compiler:incremental-compilation-impl:test")
         dependsOn(":core:descriptors.runtime:test")
+
+        dependsOn("jvmCompilerIntegrationTest")
     }
 
-    create("toolsTest") {
+    register("toolsTest") {
         dependsOn(":tools:kotlinp:test")
     }
 
-    create("examplesTest") {
+    register("examplesTest") {
         dependsOn("dist")
         (project(":examples").subprojects + project(":kotlin-gradle-subplugin-example")).forEach { p ->
             dependsOn("${p.path}:check")
         }
     }
 
-    create("distTest") {
+    register("distTest") {
         dependsOn("compilerTest")
         dependsOn("toolsTest")
         dependsOn("gradlePluginTest")
         dependsOn("examplesTest")
     }
 
-    create("specTest") {
+    register("specTest") {
         dependsOn("dist")
         dependsOn(":compiler:tests-spec:test")
     }
 
-    create("androidCodegenTest") {
+    register("androidCodegenTest") {
         dependsOn(":compiler:android-tests:test")
     }
 
-    create("jps-tests") {
+    register("jps-tests") {
         dependsOn("dist")
         dependsOn(":jps-plugin:test")
     }
 
-    create("idea-plugin-main-tests") {
+    register("konan-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":native:kotlin-klib-commonizer:test"
+        )
+    }
+
+    register("idea-plugin-main-tests") {
         dependsOn("dist")
         dependsOn(":idea:test")
     }
 
-    create("idea-plugin-additional-tests") {
+    register("idea-plugin-additional-tests") {
         dependsOn("dist")
         dependsOn(
             ":idea:idea-gradle:test",
@@ -576,19 +652,36 @@ tasks {
             ":idea:jvm-debugger:jvm-debugger-core:test",
             ":idea:jvm-debugger:jvm-debugger-evaluation:test",
             ":idea:jvm-debugger:jvm-debugger-sequence:test",
-            ":idea:jvm-debugger:eval4j:test"
+            ":idea:jvm-debugger:eval4j:test",
+            ":idea:scripting-support:test"
         )
     }
 
-    create("idea-plugin-tests") {
+    register("idea-new-project-wizard-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":libraries:tools:new-project-wizard:test",
+            ":libraries:tools:new-project-wizard:new-project-wizard-cli:test"
+        )
+    }
+
+    register("idea-plugin-tests") {
         dependsOn("dist")
         dependsOn(
             "idea-plugin-main-tests",
-            "idea-plugin-additional-tests"
+            "idea-plugin-additional-tests",
+            "idea-new-project-wizard-tests"
         )
     }
 
-    create("android-ide-tests") {
+    register("idea-plugin-performance-tests") {
+        dependsOn("dist")
+        dependsOn(
+            ":idea:performanceTests:performanceTest"
+        )
+    }
+
+    register("android-ide-tests") {
         dependsOn("dist")
         dependsOn(
             ":plugins:android-extensions-ide:test",
@@ -597,7 +690,7 @@ tasks {
         )
     }
 
-    create("plugins-tests") {
+    register("plugins-tests") {
         dependsOn("dist")
         dependsOn(
             ":kotlin-annotation-processing:test",
@@ -608,15 +701,17 @@ tasks {
             ":plugins:uast-kotlin:test",
             ":kotlin-annotation-processing-gradle:test",
             ":kotlinx-serialization-compiler-plugin:test",
-            ":kotlinx-serialization-ide-plugin:test"
+            ":kotlinx-serialization-ide-plugin:test",
+            ":idea:jvm-debugger:jvm-debugger-test:test"
         )
     }
 
 
-    create("ideaPluginTest") {
+    register("ideaPluginTest") {
         dependsOn(
             "idea-plugin-tests",
             "jps-tests",
+            "konan-tests",
             "plugins-tests",
             "android-ide-tests",
             ":generators:test"
@@ -624,13 +719,13 @@ tasks {
     }
 
 
-    create("test") {
+    register("test") {
         doLast {
             throw GradleException("Don't use directly, use aggregate tasks *-check instead")
         }
     }
 
-    create("check") {
+    register("check") {
         dependsOn("test")
     }
 }
@@ -709,17 +804,23 @@ configure<IdeaModel> {
             commonLocalDataDir,
             ".gradle",
             "dependencies",
-            "dist"
+            "dist",
+            "tmp"
         ).toSet()
     }
 }
 
-fun jdkPath(version: String): String {
+fun jdkPathOrNull(version: String): String? {
     val jdkName = "JDK_${version.replace(".", "")}"
     val jdkMajorVersion = JdkMajorVersion.valueOf(jdkName)
-    return configuredJdks.find { it.majorVersion == jdkMajorVersion }?.homeDir?.canonicalPath ?: jdkNotFoundConst
+    return configuredJdks.find { it.majorVersion == jdkMajorVersion }?.homeDir?.canonicalPath
 }
 
+fun jdkPath(version: String, vararg replacementVersions: String): String {
+    return jdkPathOrNull(version) ?: run {
+        replacementVersions.asSequence().map { jdkPathOrNull(it) }.find { it != null }
+    } ?: jdkNotFoundConst
+}
 
 fun Project.configureJvmProject(javaHome: String, javaVersion: String) {
     val currentJavaHome = File(System.getProperty("java.home")!!).canonicalPath
@@ -769,49 +870,51 @@ fun Project.configureShadowJarSubstitutionInCompileClasspath() {
     }
 }
 
-tasks.create("findShadowJarsInClasspath").doLast {
-    fun Collection<File>.printSorted(indent: String = "    ") {
-        sortedBy { it.path }.forEach { println(indent + it.relativeTo(rootProject.projectDir)) }
-    }
-
-    val mainJars = hashSetOf<File>()
-    val shadowJars = hashSetOf<File>()
-    for (project in rootProject.allprojects) {
-        project.withJavaPlugin {
-            project.sourceSets.forEach { sourceSet ->
-                val jarTask = project.tasks.findByPath(sourceSet.jarTaskName) as? Jar
-                jarTask?.outputFile?.let { mainJars.add(it) }
-            }
+tasks.register("findShadowJarsInClasspath") {
+    doLast {
+        fun Collection<File>.printSorted(indent: String = "    ") {
+            sortedBy { it.path }.forEach { println(indent + it.relativeTo(rootProject.projectDir)) }
         }
-        for (task in project.tasks) {
-            when (task) {
-                is ShadowJar -> {
-                    shadowJars.add(fileFrom(task.outputFile))
+
+        val mainJars = hashSetOf<File>()
+        val shadowJars = hashSetOf<File>()
+        for (project in rootProject.allprojects) {
+            project.withJavaPlugin {
+                project.sourceSets.forEach { sourceSet ->
+                    val jarTask = project.tasks.findByPath(sourceSet.jarTaskName) as? Jar
+                    jarTask?.outputFile?.let { mainJars.add(it) }
                 }
-                is ProGuardTask -> {
-                    shadowJars.addAll(task.outputs.files.toList())
+            }
+            for (task in project.tasks) {
+                when (task) {
+                    is ShadowJar -> {
+                        shadowJars.add(fileFrom(task.outputFile))
+                    }
+                    is ProGuardTask -> {
+                        shadowJars.addAll(task.outputs.files.toList())
+                    }
                 }
             }
         }
-    }
 
-    shadowJars.removeAll(mainJars)
-    println("Shadow jars that might break incremental compilation:")
-    shadowJars.printSorted()
+        shadowJars.removeAll(mainJars)
+        println("Shadow jars that might break incremental compilation:")
+        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()
+        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.sourceSetsOrNull?.forEach { sourceSet ->
-            project.checkConfig(sourceSet.compileClasspathConfigurationName)
+        for (project in rootProject.allprojects) {
+            project.sourceSetsOrNull?.forEach { sourceSet ->
+                project.checkConfig(sourceSet.compileClasspathConfigurationName)
+            }
         }
     }
 }

buildSrc/build.gradle.kts

@@ -1,6 +1,3 @@
-import java.util.Properties
-
-extra["versions.shadow"] = "4.0.3"
 extra["versions.native-platform"] = "0.14"
 
 buildscript {
@@ -12,8 +9,10 @@ buildscript {
     repositories {
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/jcenter.bintray.com")
+            maven("https://cache-redirector.jetbrains.com/kotlin.bintray.com/kotlin-dependencies")
         } else {
             jcenter()
+            maven("https://kotlin.bintray.com/kotlin-dependencies")
         }
 
         buildSrcKotlinRepo?.let {
@@ -22,6 +21,7 @@ buildscript {
     }
 
     dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$buildSrcKotlinVersion")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:$buildSrcKotlinVersion")
     }
@@ -45,10 +45,6 @@ plugins {
 
 gradlePlugin {
     plugins {
-        register("pill-configurable") {
-            id = "pill-configurable"
-            implementationClass = "org.jetbrains.kotlin.pill.PillConfigurablePlugin"
-        }
         register("jps-compatible") {
             id = "jps-compatible"
             implementationClass = "org.jetbrains.kotlin.pill.JpsCompatiblePlugin"
@@ -66,26 +62,26 @@ rootProject.apply {
     from(rootProject.file("../gradle/versions.gradle.kts"))
 }
 
-val flags = LocalBuildProperties(project)
-
-val isTeamcityBuild = flags.isTeamcityBuild
-val intellijUltimateEnabled by extra(flags.intellijUltimateEnabled)
+val isTeamcityBuild = kotlinBuildProperties.isTeamcityBuild
+val intellijUltimateEnabled by extra(kotlinBuildProperties.intellijUltimateEnabled)
 val intellijSeparateSdks by extra(project.getBooleanProperty("intellijSeparateSdks") ?: false)
 val verifyDependencyOutput by extra( getBooleanProperty("kotlin.build.dependency.output.verification") ?: isTeamcityBuild)
 
-extra["intellijReleaseType"] = if (extra["versions.intellijSdk"]?.toString()?.endsWith("SNAPSHOT") == true)
-    "snapshots"
-else
-    "releases"
+extra["intellijReleaseType"] = when {
+    extra["versions.intellijSdk"]?.toString()?.contains("-EAP-") == true -> "snapshots"
+    extra["versions.intellijSdk"]?.toString()?.endsWith("SNAPSHOT") == true -> "nightly"
+    else -> "releases"
+}
 
 extra["versions.androidDxSources"] = "5.0.0_r2"
 
 extra["customDepsOrg"] = "kotlin.build"
 
 repositories {
-    maven("https://jetbrains.bintray.com/intellij-third-party-dependencies/")
-    maven("https://plugins.gradle.org/m2/")
     jcenter()
+    maven("https://jetbrains.bintray.com/intellij-third-party-dependencies/")
+    maven("https://kotlin.bintray.com/kotlin-dependencies")
+    gradlePluginPortal()
 
     extra["buildSrcKotlinRepo"]?.let {
         maven(url = it)
@@ -93,16 +89,18 @@ repositories {
 }
 
 dependencies {
-    compile(kotlin("stdlib", embeddedKotlinVersion))
-    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")
+    implementation(kotlin("stdlib", embeddedKotlinVersion))
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
 
-    compile("com.github.jengelman.gradle.plugins:shadow:${property("versions.shadow")}")
-    compile("org.jetbrains.intellij.deps:asm-all:7.0.1")
+    implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
+    implementation("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")
+    implementation("net.rubygrapefruit:native-platform-windows-i386:${property("versions.native-platform")}")
+    implementation("com.jakewharton.dex:dex-method-list:3.0.0")
 
-    compile("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
+    implementation("com.github.jengelman.gradle.plugins:shadow:${rootProject.extra["versions.shadow"]}")
+    implementation("org.jetbrains.intellij.deps:asm-all:7.0.1")
+
+    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 }
 
 samWithReceiver {
@@ -126,30 +124,3 @@ allprojects {
         apply(from = "$rootDir/../gradle/cacheRedirector.gradle.kts")
     }
 }
-
-// TODO: hide these classes in special gradle plugin for kotlin-ultimate which will support local.properties
-class LocalBuildPropertiesProvider(private val project: Project) {
-    private val localProperties: Properties = Properties()
-
-    val rootProjectDir: File = project.rootProject.rootDir.parentFile
-
-    init {
-        rootProjectDir.resolve("local.properties").takeIf { it.isFile }?.let {
-            it.reader().use(localProperties::load)
-        }
-    }
-
-    fun getString(name: String): String? = project.findProperty(name)?.toString() ?: localProperties[name]?.toString()
-
-    fun getBoolean(name: String): Boolean = getString(name)?.toBoolean() == true
-}
-
-class LocalBuildProperties(project: Project) {
-    val propertiesProvider = LocalBuildPropertiesProvider(project)
-
-    val isTeamcityBuild = propertiesProvider.getString("teamcity") != null || System.getenv("TEAMCITY_VERSION") != null
-
-    val intellijUltimateEnabled =
-        (propertiesProvider.getBoolean("intellijUltimateEnabled") || isTeamcityBuild)
-                && propertiesProvider.rootProjectDir.resolve("kotlin-ultimate").exists()
-}

buildSrc/gradle.properties.as34

@@ -1,8 +0,0 @@
-org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m -Dfile.encoding=UTF-8
-
-cacheRedirectorEnabled=true
-
-#buildSrc.kotlin.repo=https://jcenter.bintray.com
-#buildSrc.kotlin.version=1.1.50
-
-intellijUltimateEnabled=false

buildSrc/prepare-deps/build.gradle.kts

@@ -104,15 +104,18 @@ val nodeJSPlugin by configurations.creating
  */
 val intellijRuntimeAnnotations = "intellij-runtime-annotations"
 
-val customDepsRepoDir = rootProject.rootDir.parentFile.resolve("dependencies/repo")
+val dependenciesDir = (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File)
+    ?: rootProject.rootDir.parentFile.resolve("dependencies")
+
+val customDepsRepoDir = dependenciesDir.resolve("repo")
+
 val customDepsOrg: String by rootProject.extra
 val customDepsRevision = intellijVersion
 val repoDir = File(customDepsRepoDir, customDepsOrg)
 
 dependencies {
     if (androidStudioRelease != null) {
-        val extension = if (androidStudioOs == "linux" &&
-            (androidStudioRelease.startsWith("3.5") || androidStudioRelease.startsWith("3.6")))
+        val extension = if (androidStudioOs == "linux")
             "tar.gz"
         else
             "zip"
@@ -141,7 +144,7 @@ dependencies {
 
 val makeIntellijCore = buildIvyRepositoryTask(intellijCore, customDepsOrg, customDepsRepoDir)
 
-val makeIntellijAnnotations by tasks.creating(Copy::class.java) {
+val makeIntellijAnnotations by tasks.registering(Copy::class) {
     dependsOn(makeIntellijCore)
 
     from(repoDir.resolve("intellij-core/$intellijVersion/artifacts/annotations.jar"))
@@ -218,7 +221,7 @@ tasks.named("build") {
 }
 
 // Task to delete legacy repo locations
-tasks.create("cleanLegacy", Delete::class.java) {
+tasks.register<Delete>("cleanLegacy") {
     delete("$projectDir/android-dx")
     delete("$projectDir/intellij-sdk")
 }
@@ -370,10 +373,7 @@ fun writeIvyXml(
 
                     sourcesJar.forEach { jarFile ->
                         emptyElement("artifact") {
-                            val sourcesArtifactName = jarFile.name
-                                .substringBeforeLast("-")
-                                .substringBeforeLast("-")
-
+                            val sourcesArtifactName = jarFile.name.substringBefore("-$version")
                             attributes(
                                 "name" to sourcesArtifactName,
                                 "type" to "jar",

buildSrc/settings.gradle

@@ -11,68 +11,61 @@ pluginManagement {
     }
 }
 
+buildscript {
+    repositories {
+        if (cacheRedirectorEnabled == 'true') {
+            maven { url "https://cache-redirector.jetbrains.com/kotlin.bintray.com/kotlin-dependencies" }
+        } else {
+            maven { url "https://kotlin.bintray.com/kotlin-dependencies" }
+        }
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
+    }
+}
+
+def buildProperties = BuildPropertiesKt.getKotlinBuildPropertiesForSettings(settings)
+def projectVersions = file("../gradle/versions.properties").text
+
+BuildCacheKt.setupBuildCache(settings)
+
 include "prepare-deps"
 
-def flags = new LocalBuildProperties(settings as Settings)
+def target_AppCode_Clion = buildProperties.includeCidrPlugins && !projectVersions.contains("versions.androidStudioRelease")
+def target_AndroidStudio = buildProperties.includeCidrPlugins && projectVersions.contains("versions.androidStudioRelease")
+def target_IdeaUltimate = buildProperties.includeUltimate
+
+if (target_AppCode_Clion) {
+    logger.info("Including modules for AC and CL in buildSrc/settings.gradle")
 
-if (flags.includeCidrPlugins) {
-    logger.info("Including CIDR plugins in buildSrc/settings.gradle")
     include ":prepare-deps:kotlin-native-platform-deps"
-    project(":prepare-deps:kotlin-native-platform-deps").projectDir = file("${flags.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/kotlin-native-platform-deps")
-} else {
-    logger.info("NOT including CIDR plugins in buildSrc/settings.gradle")
-}
 
-if (flags.hasKotlinUltimate) {
-    logger.info("Including extension for IJ Ultimate in buildSrc/settings.gradle")
+    project(":prepare-deps:kotlin-native-platform-deps").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/kotlin-native-platform-deps")
+} else if (target_AndroidStudio) {
+    logger.info("Including modules for AS (mobile plugin) in buildSrc/settings.gradle")
+
+    include ":prepare-deps:cocoa-common-binaries"
+    include ":prepare-deps:lldb-framework"
+    include ":prepare-deps:lldb-frontend"
+
+    project(":prepare-deps:cocoa-common-binaries").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/cocoa-common-binaries")
+    project(":prepare-deps:lldb-framework").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-framework")
+    project(":prepare-deps:lldb-frontend").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-frontend")
+} else if (target_IdeaUltimate) {
+    logger.info("Including modules for IU in buildSrc/settings.gradle")
+
     include ":prepare-deps:lldb-frontend"
     include ":prepare-deps:native-debug-plugin"
-    project(":prepare-deps:lldb-frontend").projectDir = file("${flags.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-frontend")
-    project(":prepare-deps:native-debug-plugin").projectDir = file("${flags.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/native-debug-plugin")
+
+    project(":prepare-deps:lldb-frontend").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/lldb-frontend")
+    project(":prepare-deps:native-debug-plugin").projectDir =
+            file("${buildProperties.propertiesProvider.rootProjectDir}/kotlin-ultimate/buildSrc/prepare-deps/native-debug-plugin")
+
 } else {
-    logger.info("Not including extension for IJ Ultimate in buildSrc/settings.gradle")
-}
-
-
-class LocalBuildPropertiesProvider {
-    private Settings settings
-    private Properties localProperties = new Properties()
-
-    File rootProjectDir
-
-    LocalBuildPropertiesProvider(Settings settings) {
-        this.settings = settings
-        this.rootProjectDir = settings.rootProject.projectDir.parentFile
-        
-        File propertiesFile = new File(rootProjectDir, 'local.properties')
-        if (propertiesFile.isFile()) {
-            propertiesFile.withInputStream { localProperties.load(it) }
-        }
-    }
-    
-    String getString(String name) {
-        if (settings.hasProperty(name)) {
-            return settings[name]?.toString()
-        } else {
-            return localProperties[name]?.toString()
-        }
-    }
-    
-    Boolean getBoolean(String name) {
-        return Boolean.parseBoolean(getString(name))
-    }
-}
-
-class LocalBuildProperties {
-    LocalBuildPropertiesProvider propertiesProvider
-    
-    boolean includeCidrPlugins
-
-    boolean hasKotlinUltimate
-
-    LocalBuildProperties(Settings settings) {
-        propertiesProvider = new LocalBuildPropertiesProvider(settings)
-        hasKotlinUltimate = new File(propertiesProvider.rootProjectDir, 'kotlin-ultimate').exists()
-        includeCidrPlugins = propertiesProvider.getBoolean('cidrPluginsEnabled') && hasKotlinUltimate
-    }
-}
+    logger.info("Not including extra modules in buildSrc/settings.gradle")
+}

buildSrc/src/main/kotlin/Bootstrap.kt

@@ -2,18 +2,24 @@
 
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.*
+import java.net.URI
 
 
 var Project.bootstrapKotlinVersion: String
     get() = this.property("bootstrapKotlinVersion") as String
-    private set(value) { this.extra["bootstrapKotlinVersion"] = value }
+    private set(value) {
+        this.extra["bootstrapKotlinVersion"] = value
+    }
 
 var Project.bootstrapKotlinRepo: String?
     get() = this.property("bootstrapKotlinRepo") as String?
-    private set(value) { this.extra["bootstrapKotlinRepo"] = value }
+    private set(value) {
+        this.extra["bootstrapKotlinRepo"] = value
+    }
 
 val Project.internalKotlinRepo: String?
-    get() = bootstrapKotlinRepo?.replace("artifacts/content/maven/", "artifacts/content/internal/repo")
+    get() = "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:$bootstrapKotlinVersion," +
+            "branch:default:any/artifacts/content/internal/repo"
 
 fun Project.kotlinBootstrapFrom(defaultSource: BootstrapOption) {
     val customVersion = project.findProperty("bootstrap.kotlin.version") as String?
@@ -23,8 +29,16 @@ fun Project.kotlinBootstrapFrom(defaultSource: BootstrapOption) {
     val teamCityProject = project.findProperty("bootstrap.teamcity.project") as String?
 
     val bootstrapSource = when {
-        project.hasProperty("bootstrap.local") -> BootstrapOption.Local(project.findProperty("bootstrap.local.version") as String?, project.findProperty("bootstrap.local.path") as String?)
-        teamCityVersion != null -> BootstrapOption.TeamCity(teamCityVersion, teamCityBuild, projectExtId = teamCityProject, onlySuccessBootstrap = false)
+        project.hasProperty("bootstrap.local") -> BootstrapOption.Local(
+            project.findProperty("bootstrap.local.version") as String?,
+            project.findProperty("bootstrap.local.path") as String?
+        )
+        teamCityVersion != null -> BootstrapOption.TeamCity(
+            teamCityVersion,
+            teamCityBuild,
+            projectExtId = teamCityProject,
+            onlySuccessBootstrap = false
+        )
         customVersion != null -> BootstrapOption.Custom(kotlinVersion = customVersion, repo = customRepo)
         else -> defaultSource
     }
@@ -40,15 +54,23 @@ sealed class BootstrapOption {
      *
      *  If [repo] is not specified the default buildscript and project repositories are used
      */
-    open class Custom(val kotlinVersion: String, val repo: String?) : BootstrapOption() {
+    open class Custom(val kotlinVersion: String, val repo: String?, val cacheRedirector: Boolean = false) : BootstrapOption() {
         override fun applyToProject(project: Project) {
             project.bootstrapKotlinVersion = kotlinVersion
-            project.bootstrapKotlinRepo = repo
+            project.bootstrapKotlinRepo = if (cacheRedirector)
+                repo?.let { URI(it) }?.let { "https://cache-redirector.jetbrains.com/${it.host}/${it.path}" }
+            else
+                repo
         }
     }
 
-    /** Get bootstrap from kotlin-dev bintray repo, where bootstraps are published */
-    class BintrayDev(kotlinVersion: String) : Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-dev")
+    /** Get bootstrap from kotlin-dev bintray repo */
+    class BintrayDev(kotlinVersion: String, cacheRedirector: Boolean = false) :
+        Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-dev", cacheRedirector)
+
+    /** Get bootstrap from kotlin-bootstrap bintray repo, where bootstraps are published */
+    class BintrayBootstrap(kotlinVersion: String, cacheRedirector: Boolean = false) :
+        Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-bootstrap", cacheRedirector)
 
     /** Get bootstrap from teamcity maven artifacts of the specified build configuration
      *
@@ -57,10 +79,17 @@ sealed class BootstrapOption {
      * [projectExtId] extId of a teamcity build configuration, by default "Kotlin_dev_Compiler",
      * [onlySuccessBootstrap] allow artifacts only from success builds of the default branch tagged with 'bootstrap' tag
      */
-    class TeamCity(val kotlinVersion: String, val buildNumber: String? = null, val projectExtId: String? = null, val onlySuccessBootstrap: Boolean = true) : BootstrapOption() {
+    class TeamCity(
+        val kotlinVersion: String,
+        val buildNumber: String? = null,
+        val projectExtId: String? = null,
+        val onlySuccessBootstrap: Boolean = true,
+        val teamcityUrl: String = "https://teamcity.jetbrains.com"
+    ) : BootstrapOption() {
         override fun applyToProject(project: Project) {
             val query = if (onlySuccessBootstrap) "status:SUCCESS,tag:bootstrap,pinned:true" else "branch:default:any"
-            project.bootstrapKotlinRepo = "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:${projectExtId ?: "Kotlin_dev_Compiler"}),number:${buildNumber ?: kotlinVersion},$query/artifacts/content/maven/"
+            project.bootstrapKotlinRepo = "$teamcityUrl/guestAuth/app/rest/builds/buildType:(id:${projectExtId
+                ?: "Kotlin_dev_Compiler"}),number:${buildNumber ?: kotlinVersion},$query/artifacts/content/maven/"
             project.bootstrapKotlinVersion = kotlinVersion
         }
     }

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -10,13 +10,13 @@ import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.api.tasks.SourceSetOutput
-import org.gradle.kotlin.dsl.creating
-import org.gradle.kotlin.dsl.extra
-import org.gradle.kotlin.dsl.the
+import org.gradle.kotlin.dsl.*
 import java.io.File
 import java.util.concurrent.Callable
 
-inline fun <reified T : Task> Project.task(noinline configuration: T.() -> Unit) = tasks.creating(T::class, configuration)
+inline fun <reified T : Task> Project.task(noinline configuration: T.() -> Unit) = tasks.registering(T::class, configuration)
+
+inline fun <reified T : Task> Project.eagerTask(noinline configuration: T.() -> Unit) = tasks.creating(T::class, configuration)
 
 fun Project.callGroovy(name: String, vararg args: Any?): Any? {
     return (property(name) as Closure<*>).call(*args)
@@ -67,3 +67,5 @@ fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)
 inline fun CopySourceSpec.from(crossinline filesProvider: () -> Any?): CopySourceSpec = from(Callable { filesProvider() })
 
 fun Project.javaPluginConvention(): JavaPluginConvention = the()
+
+fun Project.findJavaPluginConvention(): JavaPluginConvention? = convention.findByType() ?: convention.findPlugin()

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P181, P182, P183, P191, P192;
+    P183, P191, P192, P193, P201;
 
     val version: Int = name.drop(1).toInt()
 
@@ -41,17 +41,14 @@ enum class Platform : CompatibilityPredicate {
 }
 
 enum class Ide(val platform: Platform) : CompatibilityPredicate {
-    IJ181(Platform.P181),
-    IJ182(Platform.P182),
-    IJ183(Platform.P183),
     IJ191(Platform.P191),
     IJ192(Platform.P192),
+    IJ193(Platform.P193),
+    IJ201(Platform.P201),
 
-    AS32(Platform.P181),
-    AS33(Platform.P182),
-    AS34(Platform.P183),
     AS35(Platform.P183),
-    AS36(Platform.P192);
+    AS36(Platform.P192),
+    AS40(Platform.P193);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/SmartJavaExec.kt

@@ -1,6 +1,7 @@
 import org.gradle.api.Project
 import org.gradle.api.tasks.JavaExec
 import org.gradle.jvm.tasks.Jar
+import org.gradle.kotlin.dsl.creating
 import org.gradle.kotlin.dsl.task
 
 /*
@@ -8,7 +9,8 @@ import org.gradle.kotlin.dsl.task
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
-fun Project.smartJavaExec(configure: JavaExec.() -> Unit) = task<JavaExec> {
+// creating class eagerly here: using register causes problems due to quite complicated relationships between these tasks
+fun Project.smartJavaExec(configure: JavaExec.() -> Unit) = tasks.creating(JavaExec::class) {
     configure()
     passClasspathInJar()
 }

buildSrc/src/main/kotlin/artifacts.kt

@@ -8,17 +8,12 @@ import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ConfigurationContainer
 import org.gradle.api.artifacts.component.ProjectComponentIdentifier
 import org.gradle.api.file.DuplicatesStrategy
-import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.plugins.BasePluginConvention
-import org.gradle.api.plugins.JavaPluginConvention
-import org.gradle.api.tasks.AbstractCopyTask
-import org.gradle.api.tasks.Copy
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.Upload
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.*
-import java.io.File
 
 
 private const val MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME = "testJar"
@@ -52,11 +47,11 @@ fun Project.removeArtifacts(configuration: Configuration, task: Task) {
 }
 
 fun Project.noDefaultJar() {
-    tasks.findByName("jar")?.let { defaultJarTask ->
-        defaultJarTask.enabled = false
-        defaultJarTask.actions = emptyList()
+    tasks.named("jar").configure {
+        enabled = false
+        actions = emptyList()
         configurations.forEach { cfg ->
-            removeArtifacts(cfg, defaultJarTask)
+            removeArtifacts(cfg, this)
         }
     }
 }
@@ -69,12 +64,11 @@ fun Project.runtimeJarArtifactBy(task: Task, artifactRef: Any, body: Configurabl
     }
 }
 
-fun <T : Jar> Project.runtimeJar(task: T, body: T.() -> Unit = {}): T {
-    extra["runtimeJarTask"] = task
-    tasks.findByName("jar")?.let { defaultJarTask ->
-        removeArtifacts(configurations.getOrCreate("archives"), defaultJarTask)
+fun <T : Jar> Project.runtimeJar(task: TaskProvider<T>, body: T.() -> Unit = {}): TaskProvider<T> {
+    tasks.named<Jar>("jar").configure {
+        removeArtifacts(configurations.getOrCreate("archives"), this)
     }
-    return task.apply {
+    task.configure {
         configurations.findByName("embedded")?.let { embedded ->
             dependsOn(embedded)
             from {
@@ -86,9 +80,10 @@ fun <T : Jar> Project.runtimeJar(task: T, body: T.() -> Unit = {}): T {
         body()
         project.runtimeJarArtifactBy(this, this)
     }
+    return task
 }
 
-fun Project.runtimeJar(body: Jar.() -> Unit = {}): Jar = runtimeJar(getOrCreateTask("jar", body), { })
+fun Project.runtimeJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> = runtimeJar(getOrCreateTask("jar", body), { })
 
 fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     val task = tasks.register<Jar>("sourcesJar") {
@@ -103,7 +98,12 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
                     .resolvedArtifacts
                     .map { it.id.componentIdentifier }
                     .filterIsInstance<ProjectComponentIdentifier>()
-                    .map { project(it.projectPath).mainSourceSet.allSource }
+                    .mapNotNull {
+                        project(it.projectPath)
+                            .findJavaPluginConvention()
+                            ?.mainSourceSet
+                            ?.allSource
+                    }
             })
         }
 
@@ -116,15 +116,19 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     return task
 }
 
-fun Project.javadocJar(body: Jar.() -> Unit = {}): Jar = getOrCreateTask("javadocJar") {
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    classifier = "javadoc"
-    tasks.findByName("javadoc")?.let { it as Javadoc }?.takeIf { it.enabled }?.let {
-        dependsOn(it)
-        from(it.destinationDir)
+fun Project.javadocJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
+    val javadocTask = getOrCreateTask<Jar>("javadocJar") {
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+        archiveClassifier.set("javadoc")
+        tasks.findByName("javadoc")?.let { it as Javadoc }?.takeIf { it.enabled }?.let {
+            dependsOn(it)
+            from(it.destinationDir)
+        }
+        body()
     }
-    body()
-    project.addArtifact("archives", this, this)
+
+    addArtifact("archives", javadocTask)
+    return javadocTask
 }
 
 
@@ -151,11 +155,6 @@ fun Project.publish(body: Upload.() -> Unit = {}): Upload {
     }
 }
 
-private fun Project.runtimeJarTaskIfExists(): Task? =
-    if (extra.has("runtimeJarTask")) extra["runtimeJarTask"] as Task
-    else tasks.findByName("jar")
-
-
 fun ConfigurationContainer.getOrCreate(name: String): Configuration = findByName(name) ?: create(name)
 
 fun Jar.setupPublicJar(baseName: String, classifier: String = "") {

buildSrc/src/main/kotlin/buildProperties.kt

@@ -1,117 +0,0 @@
-import org.gradle.api.Project
-import org.gradle.api.initialization.Settings
-import org.gradle.api.internal.DynamicObjectAware
-import java.io.File
-import java.util.*
-
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-interface PropertiesProvider {
-    val rootProjectDir: File
-    fun getProperty(key: String): Any?
-}
-
-class KotlinBuildProperties(
-    private val propertiesProvider: PropertiesProvider
-) {
-    private val localProperties: Properties = Properties()
-
-    init {
-        val localPropertiesFile = propertiesProvider.rootProjectDir.resolve("local.properties")
-        if (localPropertiesFile.isFile) {
-            localPropertiesFile.reader().use(localProperties::load)
-        }
-    }
-
-    private operator fun get(key: String): Any? = localProperties.getProperty(key) ?: propertiesProvider.getProperty(key)
-
-    private fun getBoolean(key: String, default: Boolean = false): Boolean =
-        (this[key]?.toString()?.toBoolean() ?: default) == true
-
-    val isJpsBuildEnabled: Boolean = getBoolean("jpsBuild")
-
-    val isInIdeaSync: Boolean = run {
-        // "idea.sync.active" was introduced in 2019.1
-        System.getProperty("idea.sync.active")?.toBoolean() == true || let {
-            // before 2019.1 there is "idea.active" that was true only on sync,
-            // but since 2019.1 "idea.active" present in task execution too.
-            // So let's check Idea version
-            val majorIdeaVersion = System.getProperty("idea.version")
-                ?.split(".")
-                ?.getOrNull(0)
-            val isBeforeIdea2019 = majorIdeaVersion == null || majorIdeaVersion.toInt() < 2019
-
-            isBeforeIdea2019 && System.getProperty("idea.active")?.toBoolean() == true
-        }
-    }
-
-    val isInJpsBuildIdeaSync: Boolean
-        get() = isJpsBuildEnabled && isInIdeaSync
-
-    val includeJava9: Boolean
-        get() = !isInJpsBuildIdeaSync && getBoolean("kotlin.build.java9", true)
-
-    val useBootstrapStdlib: Boolean
-        get() = isInJpsBuildIdeaSync || getBoolean("kotlin.build.useBootstrapStdlib", false)
-
-    private val kotlinUltimateExists: Boolean = propertiesProvider.rootProjectDir.resolve("kotlin-ultimate").exists()
-
-    val isTeamcityBuild: Boolean = getBoolean("teamcity") || System.getenv("TEAMCITY_VERSION") != null
-
-    val intellijUltimateEnabled: Boolean
-        get() {
-            val explicitlyEnabled = getBoolean("intellijUltimateEnabled")
-            if (!kotlinUltimateExists && explicitlyEnabled) {
-                error("intellijUltimateEnabled property is set, while kotlin-ultimate repository is not provided")
-            }
-            return kotlinUltimateExists && (explicitlyEnabled || isTeamcityBuild)
-        }
-
-    val includeCidrPlugins: Boolean = kotlinUltimateExists && getBoolean("cidrPluginsEnabled")
-
-    val includeUltimate: Boolean = kotlinUltimateExists && (isTeamcityBuild || intellijUltimateEnabled)
-
-    val postProcessing: Boolean get() = isTeamcityBuild || getBoolean("kotlin.build.postprocessing", true)
-
-    val relocation: Boolean get() = postProcessing
-
-    val proguard: Boolean get() = postProcessing && getBoolean("kotlin.build.proguard", isTeamcityBuild)
-
-    val jsIrDist: Boolean get() = getBoolean("kotlin.stdlib.js.ir.dist")
-}
-
-private const val extensionName = "kotlinBuildProperties"
-
-class ProjectProperties(val project: Project) : PropertiesProvider {
-    override val rootProjectDir: File
-        get() = project.projectDir
-
-    override fun getProperty(key: String): Any? = project.findProperty(key)
-}
-
-val Project.kotlinBuildProperties: KotlinBuildProperties
-    get() = rootProject.extensions.findByName(extensionName) as KotlinBuildProperties?
-        ?: KotlinBuildProperties(ProjectProperties(rootProject)).also {
-            rootProject.extensions.add(extensionName, it)
-        }
-
-class SettingsProperties(val settings: Settings) : PropertiesProvider {
-    override val rootProjectDir: File
-        get() = settings.rootDir
-
-    override fun getProperty(key: String): Any? {
-        val obj = (settings as DynamicObjectAware).asDynamicObject
-        return if (obj.hasProperty(key)) obj.getProperty(key) else null
-    }
-}
-
-fun getKotlinBuildPropertiesForSettings(settings: Any) = (settings as Settings).kotlinBuildProperties
-
-val Settings.kotlinBuildProperties: KotlinBuildProperties
-    get() = extensions.findByName(extensionName) as KotlinBuildProperties?
-        ?: KotlinBuildProperties(SettingsProperties(this)).also {
-            extensions.add(extensionName, it)
-        }

buildSrc/src/main/kotlin/dependencies.kt

@@ -8,14 +8,21 @@ import org.gradle.api.Project
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.AbstractCopyTask
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File
 
-val Project.isSnapshotIntellij get() = rootProject.extra["versions.intellijSdk"].toString().endsWith("SNAPSHOT")
+private val Project.isEAPIntellij get() = rootProject.extra["versions.intellijSdk"].toString().contains("-EAP-")
+private val Project.isNightlyIntellij get() = rootProject.extra["versions.intellijSdk"].toString().endsWith("SNAPSHOT") && !isEAPIntellij
 
-val Project.intellijRepo get() = "https://www.jetbrains.com/intellij-repository/" + if (isSnapshotIntellij) "snapshots" else "releases"
+val Project.intellijRepo get() =
+    when {
+        isEAPIntellij -> "https://www.jetbrains.com/intellij-repository/snapshots"
+        isNightlyIntellij -> "https://www.jetbrains.com/intellij-repository/nightly"
+        else -> "https://www.jetbrains.com/intellij-repository/releases"
+    }
 
 fun Project.commonDep(coord: String): String {
     val parts = coord.split(':')
@@ -128,7 +135,9 @@ fun Project.firstFromJavaHomeThatExists(vararg paths: String, jdkHome: File = Fi
             logger.warn("Cannot find file by paths: ${paths.toList()} in $jdkHome")
     }
 
-fun Project.toolsJar(jdkHome: File = File(this.property("JDK_18") as String)): File? =
+fun Project.toolsJar(): FileCollection = files(toolsJarFile() ?: error("tools.jar is not found!"))
+
+fun Project.toolsJarFile(jdkHome: File = File(this.property("JDK_18") as String)): File? =
     firstFromJavaHomeThatExists("lib/tools.jar", jdkHome = jdkHome)
 
 val compilerManifestClassPath

buildSrc/src/main/kotlin/embeddable.kt

@@ -3,8 +3,8 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.Project
 import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.jvm.tasks.Jar
-import org.gradle.kotlin.dsl.task
 import org.gradle.kotlin.dsl.*
 import java.io.File
 
@@ -59,12 +59,12 @@ private fun ShadowJar.configureEmbeddableCompilerRelocation(withJavaxInject: Boo
     }
 }
 
-private fun Project.compilerShadowJar(taskName: String, body: ShadowJar.() -> Unit): Jar {
+private fun Project.compilerShadowJar(taskName: String, body: ShadowJar.() -> Unit): TaskProvider<out ShadowJar> {
 
     val compilerJar = configurations.getOrCreate("compilerJar")
     dependencies.add(compilerJar.name, dependencies.project(":kotlin-compiler", configuration = "runtimeJar"))
 
-    return task<ShadowJar>(taskName) {
+    return tasks.register<ShadowJar>(taskName) {
         destinationDir = File(buildDir, "libs")
         setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
         from(compilerJar)
@@ -72,31 +72,39 @@ private fun Project.compilerShadowJar(taskName: String, body: ShadowJar.() -> Un
     }
 }
 
-fun Project.embeddableCompiler(taskName: String = "embeddable", body: ShadowJar.() -> Unit = {}): Jar =
-        compilerShadowJar(taskName) {
-            configureEmbeddableCompilerRelocation()
-            body()
-        }
+fun Project.embeddableCompiler(taskName: String = "embeddable", body: ShadowJar.() -> Unit = {}): TaskProvider<out ShadowJar> =
+    compilerShadowJar(taskName) {
+        configureEmbeddableCompilerRelocation()
+        body()
+    }
 
-fun Project.compilerDummyForDependenciesRewriting(taskName: String = "compilerDummy", body: ShadowJar.() -> Unit = {}): Jar =
-        compilerShadowJar(taskName) {
-            exclude(packagesToExcludeFromDummy)
-            body()
-        }
+fun Project.compilerDummyForDependenciesRewriting(
+    taskName: String = "compilerDummy", body: ShadowJar.() -> Unit = {}
+): TaskProvider<out Jar> =
+    compilerShadowJar(taskName) {
+        exclude(packagesToExcludeFromDummy)
+        body()
+    }
 
 const val COMPILER_DUMMY_JAR_CONFIGURATION_NAME = "compilerDummyJar"
 
-fun Project.compilerDummyJar(task: Jar, body: Jar.() -> Unit = {}) {
-    task.body()
-    addArtifact(COMPILER_DUMMY_JAR_CONFIGURATION_NAME, task, task)
+fun Project.compilerDummyJar(task: TaskProvider<out Jar>, body: Jar.() -> Unit = {}) {
+    task.configure(body)
+    task.configure {
+        addArtifact(COMPILER_DUMMY_JAR_CONFIGURATION_NAME, this, this)
+    }
 }
 
-fun Project.embeddableCompilerDummyForDependenciesRewriting(taskName: String = "embeddable", body: Jar.() -> Unit = {}): Jar {
+fun Project.embeddableCompilerDummyForDependenciesRewriting(
+    taskName: String = "embeddable", body: Jar.() -> Unit = {}
+): TaskProvider<ShadowJar> {
     val compilerDummyJar = configurations.getOrCreate("compilerDummyJar")
-    dependencies.add(compilerDummyJar.name,
-                     dependencies.project(":kotlin-compiler-embeddable", configuration = COMPILER_DUMMY_JAR_CONFIGURATION_NAME))
+    dependencies.add(
+        compilerDummyJar.name,
+        dependencies.project(":kotlin-compiler-embeddable", configuration = COMPILER_DUMMY_JAR_CONFIGURATION_NAME)
+    )
 
-    return task<ShadowJar>(taskName) {
+    return tasks.register<ShadowJar>(taskName) {
         destinationDir = File(buildDir, "libs")
         setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
         from(compilerDummyJar)
@@ -105,14 +113,16 @@ fun Project.embeddableCompilerDummyForDependenciesRewriting(taskName: String = "
     }
 }
 
-fun Project.rewriteDepsToShadedJar(originalJarTask: Jar, shadowJarTask: Jar, body: Jar.() -> Unit = {}): Jar {
-    originalJarTask.apply {
+fun Project.rewriteDepsToShadedJar(
+    originalJarTask: TaskProvider<out Jar>, shadowJarTask: TaskProvider<out Jar>, body: Jar.() -> Unit = {}
+): TaskProvider<out Jar> {
+    originalJarTask.configure {
         classifier = "original"
     }
 
     val compilerDummyJarFile by lazy { configurations.getAt("compilerDummyJar").singleFile }
 
-    return shadowJarTask.apply {
+    shadowJarTask.configure {
         dependsOn(originalJarTask)
         from(originalJarTask)// { include("**") }
 
@@ -123,7 +133,11 @@ fun Project.rewriteDepsToShadedJar(originalJarTask: Jar, shadowJarTask: Jar, bod
         classifier = ""
         body()
     }
+    return shadowJarTask
 }
 
-fun Project.rewriteDepsToShadedCompiler(originalJarTask: Jar, body: Jar.() -> Unit = {}): Jar =
-        rewriteDepsToShadedJar(originalJarTask, embeddableCompilerDummyForDependenciesRewriting(), body)
+fun Project.rewriteDepsToShadedCompiler(originalJarTask: TaskProvider<out Jar>, body: Jar.() -> Unit = {}): TaskProvider<out Jar> =
+    rewriteDepsToShadedJar(originalJarTask, embeddableCompilerDummyForDependenciesRewriting(), body)
+
+fun Project.rewriteDefaultJarDepsToShadedCompiler(body: Jar.() -> Unit = {}): TaskProvider<out Jar> =
+    rewriteDepsToShadedJar(tasks.named<Jar>("jar"), embeddableCompilerDummyForDependenciesRewriting(), body)

buildSrc/src/main/kotlin/instrument.kt

@@ -44,10 +44,29 @@ fun Project.configureFormInstrumentation() {
         // classes from the "friendly directory" to the compile classpath.
         val testCompile = tasks.findByName("compileTestKotlin") as AbstractCompile?
         testCompile?.doFirst {
+            val originalClassesDirs = files((mainSourceSet as ExtensionAware).extra.get("classesDirsCopy"))
+
             testCompile.classpath = (testCompile.classpath
                     - mainSourceSet.output.classesDirs
-                    + files((mainSourceSet as ExtensionAware).extra.get("classesDirsCopy")))
+                    + originalClassesDirs)
+
+            // Since Kotlin 1.3.60, the friend paths available to the test compile task are calculated as the main source set's
+            // output.classesDirs. Since the classesDirs are excluded from the classpath (replaced by the originalClassesDirs),
+            // in order to be able to access the internals of 'main', tests need to receive the original classes dirs as a
+            // -Xfriend-paths compiler argument as well.
+            fun addFreeCompilerArgs(kotlinCompileTask: AbstractCompile, vararg args: String) {
+                val getKotlinOptions = kotlinCompileTask::class.java.getMethod("getKotlinOptions")
+                val kotlinOptions = getKotlinOptions(kotlinCompileTask)
+
+                val getFreeCompilerArgs = kotlinOptions::class.java.getMethod("getFreeCompilerArgs")
+                val freeCompilerArgs = getFreeCompilerArgs(kotlinOptions) as List<*>
+
+                val setFreeCompilerArgs = kotlinOptions::class.java.getMethod("setFreeCompilerArgs", List::class.java)
+                setFreeCompilerArgs(kotlinOptions, freeCompilerArgs + args)
+            }
+            addFreeCompilerArgs(testCompile, "-Xfriend-paths=" + originalClassesDirs.joinToString(",")  { it.absolutePath })
         }
+
     }
 
     val instrumentationClasspathCfg = configurations.create("instrumentationClasspath")
@@ -68,16 +87,15 @@ fun Project.configureFormInstrumentation() {
             val instrumentedClassesDir = File(project.buildDir, "classes/${sourceSetParam.name}-instrumented")
             (sourceSetParam.output.classesDirs as ConfigurableFileCollection).setFrom(instrumentedClassesDir)
             val instrumentTask =
-                project.tasks.create(sourceSetParam.getTaskName("instrument", "classes"), IntelliJInstrumentCodeTask::class.java)
-            instrumentTask.apply {
-                dependsOn(sourceSetParam.classesTaskName).onlyIf { !classesDirsCopy.isEmpty }
-                sourceSet = sourceSetParam
-                instrumentationClasspath = instrumentationClasspathCfg
-                originalClassesDirs = classesDirsCopy
-                output = instrumentedClassesDir
-            }
+                project.tasks.register(sourceSetParam.getTaskName("instrument", "classes"), IntelliJInstrumentCodeTask::class.java) {
+                    dependsOn(sourceSetParam.classesTaskName).onlyIf { !classesDirsCopy.isEmpty }
+                    sourceSet = sourceSetParam
+                    instrumentationClasspath = instrumentationClasspathCfg
+                    originalClassesDirs = classesDirsCopy
+                    output = instrumentedClassesDir
+                    outputs.dir(instrumentedClassesDir)
+                }
 
-            instrumentTask.outputs.dir(instrumentedClassesDir)
             // Ensure that our task is invoked when the source set is built
             sourceSetParam.compiledBy(instrumentTask)
             @Suppress("UNUSED_EXPRESSION")
@@ -93,17 +111,21 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
         private const val LOADER_REF = "java2.loader"
     }
 
-    var sourceSet: SourceSet? = null
-
+    @Classpath
     var instrumentationClasspath: Configuration? = null
 
-    @Input
+    @InputFiles
+    @PathSensitive(PathSensitivity.RELATIVE)
     var originalClassesDirs: FileCollection? = null
 
     @get:Input
     var instrumentNotNull: Boolean = false
 
+    @Internal
+    var sourceSet: SourceSet? = null
+
     @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
     val sourceDirs: FileCollection
         get() = project.files(sourceSet!!.allSource.srcDirs.filter { !sourceSet!!.resources.contains(it) && it.exists() })
 

buildSrc/src/main/kotlin/jdksFinder.kt

@@ -4,6 +4,7 @@ import net.rubygrapefruit.platform.Native
 import net.rubygrapefruit.platform.WindowsRegistry
 import org.gradle.api.GradleException
 import org.gradle.api.Project
+import java.nio.file.Paths
 import java.io.File
 import net.rubygrapefruit.platform.WindowsRegistry.Key.HKEY_LOCAL_MACHINE
 import org.gradle.internal.os.OperatingSystem
@@ -25,7 +26,7 @@ fun Project.getConfiguredJdks(): List<JdkId> {
                 ?: System.getenv(jdkMajorVersion.name)
                 ?: jdkAlternativeVarNames[jdkMajorVersion]?.mapNotNull { System.getenv(it) }?.firstOrNull()
                 ?: continue
-        val explicitJdk = File(explicitJdkEnvVal)
+        val explicitJdk = Paths.get(explicitJdkEnvVal).toRealPath().toFile()
         if (!explicitJdk.isDirectory) {
             throw GradleException("Invalid environment value $jdkMajorVersion: $explicitJdkEnvVal, expecting JDK home path")
         }

buildSrc/src/main/kotlin/localDependencies.kt

@@ -23,10 +23,14 @@ import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
 import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.*
 import java.io.File
 
-private fun Project.kotlinBuildLocalRepoDir() = File("${project.rootDir.absoluteFile}/dependencies/repo")
+private fun Project.kotlinBuildLocalDependenciesDir(): File =
+    (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File) ?: project.rootDir.absoluteFile.resolve("dependencies")
+
+private fun Project.kotlinBuildLocalRepoDir(): File = kotlinBuildLocalDependenciesDir().resolve("repo")
 
 private fun Project.ideModuleName() = when (IdeVersionConfigurator.currentIde.kind) {
     Ide.Kind.AndroidStudio -> "android-studio-ide"
@@ -151,9 +155,9 @@ fun DependencyHandlerScope.excludeInAndroidStudio(rootProject: Project, block: D
     }
 }
 
-fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File, body: JavaExec.() -> Unit): JavaExec {
+fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File, body: JavaExec.() -> Unit): TaskProvider<JavaExec> {
 
-    return task<JavaExec>(name) {
+    return tasks.register<JavaExec>(name) {
         val ideaSandboxConfigDir = File(ideaSandboxDir, "config")
 
         classpath = mainSourceSet.runtimeClasspath

buildSrc/src/main/kotlin/pill/JpsCompatiblePlugin.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+@Suppress("unused")
+class JpsCompatiblePlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        project.configurations.maybeCreate(EmbeddedComponents.CONFIGURATION_NAME)
+        project.extensions.create("pill", PillExtension::class.java)
+
+        // 'jpsTest' does not require the 'tests-jar' artifact
+        project.configurations.create("jpsTest")
+
+        if (project == project.rootProject) {
+            project.tasks.create("pill") {
+                dependsOn(":pill:pill-importer:pill")
+
+                if (System.getProperty("pill.android.tests", "false") == "true") {
+                    TaskUtils.useAndroidSdk(this)
+                    TaskUtils.useAndroidJar(this)
+                }
+            }
+
+            project.tasks.create("unpill") {
+                dependsOn(":pill:pill-importer:unpill")
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/pill/PillExtension.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("PackageDirectoryMismatch")
+package org.jetbrains.kotlin.pill
+
+import java.io.File
+import org.gradle.api.Project
+
+open class PillExtension {
+    enum class Variant {
+        // Default variant (./gradlew pill)
+        BASE() {
+            override val includes = setOf(BASE)
+        },
+
+        // Full variant (./gradlew pill -Dpill.variant=full)
+        FULL() {
+            override val includes = setOf(BASE, FULL)
+        },
+
+        // Do not import the project to JPS model, but set some options for it
+        NONE() {
+            override val includes = emptySet<Variant>()
+        },
+
+        // 'BASE' if the "jps-compatible" plugin is applied, 'NONE' otherwise
+        DEFAULT() {
+            override val includes = emptySet<Variant>()
+        };
+
+        abstract val includes: Set<Variant>
+    }
+
+    open var variant: Variant = Variant.DEFAULT
+
+    open var excludedDirs: List<File> = emptyList()
+
+    @Suppress("unused")
+    fun Project.excludedDirs(vararg dirs: String) {
+        excludedDirs = excludedDirs + dirs.map { File(projectDir, it) }
+    }
+
+    @Suppress("unused")
+    fun serialize() = mapOf<String, Any?>(
+        "variant" to variant.name,
+        "excludedDirs" to excludedDirs
+    )
+}

buildSrc/src/main/kotlin/pill/context.kt

@@ -1,33 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.artifacts.*
-import org.gradle.api.artifacts.component.*
-
-class DependencyMapper(val predicate: (ResolvedArtifact) -> Boolean, val mapping: (ResolvedArtifact) -> MappedDependency?) {
-    companion object {
-        fun forProject(path: String, mapping: (ResolvedArtifact) -> MappedDependency?): DependencyMapper {
-            return DependencyMapper(
-                predicate = { artifact ->
-                    val identifier = artifact.id.componentIdentifier as? ProjectComponentIdentifier
-                    identifier?.projectPath == path
-                },
-                mapping = mapping
-            )
-        }
-
-        fun forModule(group: String, module: String, version: String?, mapping: (ResolvedArtifact) -> MappedDependency?): DependencyMapper {
-            return DependencyMapper(
-                predicate = { artifact ->
-                    val identifier = artifact.id.componentIdentifier as? ModuleComponentIdentifier
-                    identifier?.group == group && identifier?.module == module && (version == null || identifier?.version == version)
-                },
-                mapping = mapping
-            )
-        }
-    }
-}
-
-class MappedDependency(val main: PDependency?, val deferred: List<PDependency> = emptyList())
-
-class ParserContext(val dependencyMappers: List<DependencyMapper>, val variant: PillExtension.Variant)

buildSrc/src/main/kotlin/pill/dependencies.kt

@@ -1,94 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import java.io.File
-import org.gradle.api.Project
-import org.gradle.api.tasks.SourceSet
-import org.gradle.api.artifacts.*
-import org.gradle.api.artifacts.component.*
-
-data class PDependencies(val main: List<PDependency>, val deferred: List<PDependency>) {
-    fun join(): List<PDependency> {
-        return main + deferred
-    }
-}
-
-fun Project.resolveDependencies(
-    configuration: Configuration,
-    forTests: Boolean,
-    dependencyMappers: List<DependencyMapper>,
-    withEmbedded: Boolean = false
-): PDependencies {
-    val dependencies = mutableListOf<PDependency>()
-    val deferred = mutableListOf<PDependency>()
-
-    nextArtifact@ for (artifact in configuration.resolvedConfiguration.resolvedArtifacts) {
-        val identifier = artifact.id.componentIdentifier
-
-        for (mapper in dependencyMappers) {
-            if (mapper.predicate(artifact)) {
-                val mapped = mapper.mapping(artifact)
-
-                if (mapped != null) {
-                    mapped.main?.let { dependencies += it }
-                    deferred += mapped.deferred
-                }
-
-                continue@nextArtifact
-            }
-        }
-
-        fun addProjectDependency(projectPath: String) {
-            val project = rootProject.findProject(projectPath) ?: error("Cannot find project $projectPath")
-
-            fun addSourceSet(name: String, suffix: String): Boolean {
-                val sourceSet = project.sourceSets?.findByName(name)?.takeIf { !it.allSource.isEmpty() } ?: return false
-                dependencies += PDependency.Module(project.pillModuleName + '.' + suffix)
-                return true
-            }
-
-            if (forTests && artifact.classifier == "tests") {
-                addSourceSet(SourceSet.TEST_SOURCE_SET_NAME, "test") || addSourceSet(SourceSet.MAIN_SOURCE_SET_NAME, "src")
-            } else {
-                addSourceSet(SourceSet.MAIN_SOURCE_SET_NAME, "src")
-            }
-
-            if (withEmbedded) {
-                val embeddedConfiguration = project.configurations.findByName(EmbeddedComponents.CONFIGURATION_NAME)
-                if (embeddedConfiguration != null) {
-                    dependencies += resolveDependencies(embeddedConfiguration, forTests, dependencyMappers, withEmbedded).join()
-                }
-            }
-        }
-
-        when (identifier) {
-            is ProjectComponentIdentifier -> addProjectDependency(identifier.projectPath)
-            is LibraryBinaryIdentifier -> addProjectDependency(identifier.projectPath)
-            is ModuleComponentIdentifier -> {
-                val file = artifact.file
-                val library = PLibrary(file.name, classes = listOf(file))
-                dependencies += PDependency.ModuleLibrary(library)
-            }
-        }
-    }
-
-    val existingFiles = mutableSetOf<File>()
-
-    for (dependency in configuration.dependencies) {
-        if (dependency !is SelfResolvingDependency) {
-            continue
-        }
-
-        val files = dependency.resolve().filter { it !in existingFiles }.takeIf { it.isNotEmpty() } ?: continue
-        existingFiles.addAll(files)
-        val library = PLibrary(dependency.name, classes = files.toList())
-        deferred += PDependency.ModuleLibrary(library)
-    }
-
-    return PDependencies(dependencies, deferred)
-}

buildSrc/src/main/kotlin/pill/extension.kt

@@ -1,39 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import java.io.File
-import org.gradle.api.Project
-
-open class PillExtension {
-    enum class Variant {
-        // Default variant (./gradlew pill)
-        BASE() { override val includes = setOf(BASE) },
-
-        // Full variant (./gradlew pill -Dpill.variant=full)
-        FULL() { override val includes = setOf(BASE, FULL) },
-
-        // Do not import the project to JPS model, but set some options for it
-        NONE() { override val includes = emptySet<Variant>() },
-
-        // 'BASE' if the "jps-compatible" plugin is applied, 'NONE' otherwise
-        DEFAULT() { override val includes = emptySet<Variant>() };
-
-        abstract val includes: Set<Variant>
-    }
-
-    open var variant: Variant = Variant.DEFAULT
-
-    open var importAsLibrary: Boolean = false
-
-    open var excludedDirs: List<File> = emptyList()
-
-    fun Project.excludedDirs(vararg dirs: String) {
-        excludedDirs = excludedDirs + dirs.map { File(projectDir, it) }
-    }
-
-    open var libraryPath: File? = null
-        set(v) {
-            importAsLibrary = true
-            field = v
-        }
-}

buildSrc/src/main/kotlin/pill/kotlinPluginArtifact.kt

@@ -1,182 +0,0 @@
-@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.artifacts.ProjectDependency
-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
-    }
-
-    fun add(children: List<ArtifactElement>) {
-        myChildren += children
-    }
-
-    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, val outputFileName: String? = null) : ArtifactElement() {
-        override fun render(context: PathContext): xml {
-            val args = mutableListOf("id" to "file-copy", "path" to context(source))
-            if (outputFileName != null) {
-                args += "output-file-name" to outputFileName
-            }
-
-            return xml("element", *args.toTypedArray())
-        }
-    }
-
-    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, dependencyMappers: List<DependencyMapper>): PFile {
-    val root = Root()
-
-    fun Project.getProject(name: String) = findProject(name) ?: error("Cannot find project $name")
-
-    val prepareIdeaPluginProject = rootProject.getProject(":prepare:idea-plugin")
-
-    root.add(Directory("kotlinc").apply {
-        val kotlincDirectory = rootProject.extra["distKotlinHomeDir"].toString()
-        add(DirectoryCopy(File(kotlincDirectory)))
-    })
-
-    root.add(Directory("lib").apply {
-        val librariesConfiguration = prepareIdeaPluginProject.configurations.getByName("libraries")
-        add(getArtifactElements(rootProject, librariesConfiguration, dependencyMappers, false))
-
-        add(Directory("jps").apply {
-            val prepareJpsPluginProject = rootProject.getProject(":kotlin-jps-plugin")
-            add(Archive(prepareJpsPluginProject.name + ".jar").apply {
-                val jpsPluginConfiguration = prepareIdeaPluginProject.configurations.getByName("jpsPlugin")
-                add(getArtifactElements(rootProject, jpsPluginConfiguration, dependencyMappers, true))
-            })
-        })
-
-        add(Archive("kotlin-plugin.jar").apply {
-            add(FileCopy(File(rootProject.projectDir, "resources/kotlinManifest.properties")))
-
-            val embeddedConfiguration = prepareIdeaPluginProject.configurations.getByName(EmbeddedComponents.CONFIGURATION_NAME)
-            add(getArtifactElements(rootProject, embeddedConfiguration, dependencyMappers, true))
-        })
-    })
-
-    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))
-    )
-}
-
-private fun getArtifactElements(
-    rootProject: Project,
-    configuration: Configuration,
-    dependencyMappers: List<DependencyMapper>,
-    extractDependencies: Boolean
-): List<ArtifactElement> {
-    val dependencies = rootProject.resolveDependencies(configuration, false, dependencyMappers, withEmbedded = true).join()
-
-    val artifacts = mutableListOf<ArtifactElement>()
-
-    for (dependency in dependencies) {
-        when (dependency) {
-            is PDependency.Module -> {
-                val moduleOutput = ModuleOutput(dependency.name)
-
-                if (extractDependencies) {
-                    artifacts += moduleOutput
-                } else {
-                    artifacts += Archive(dependency.name + ".jar").apply {
-                        add(moduleOutput)
-                    }
-                }
-            }
-            is PDependency.Library -> artifacts += ProjectLibrary(dependency.name)
-            is PDependency.ModuleLibrary -> {
-                val files = dependency.library.classes
-                if (extractDependencies) files.mapTo(artifacts) { ExtractedDirectory(it) }
-                else  files.mapTo(artifacts) { FileCopy(it) }
-            }
-        }
-    }
-
-    return artifacts
-}

buildSrc/src/main/kotlin/pill/parser.kt

@@ -1,421 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.Project
-import org.gradle.api.artifacts.*
-import org.gradle.api.tasks.*
-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.gradle.api.internal.file.copy.CopySpecInternal
-import org.gradle.api.internal.file.copy.SingleParentCopySpec
-import org.gradle.language.jvm.tasks.ProcessResources
-import org.jetbrains.kotlin.pill.POrderRoot.*
-import org.jetbrains.kotlin.pill.PSourceRoot.*
-import org.jetbrains.kotlin.pill.PillExtension.*
-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 rootDirectory: File,
-    val moduleFile: File,
-    val contentRoots: List<PContentRoot>,
-    val orderRoots: List<POrderRoot>,
-    val moduleForProductionSources: PModule? = 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,
-    val kotlinOptions: PSourceRootKotlinOptions?
-) {
-    enum class Kind { PRODUCTION, TEST, RESOURCES, TEST_RESOURCES }
-}
-
-data class PSourceRootKotlinOptions(
-    val noStdlib: Boolean?,
-    val noReflect: Boolean?,
-    val moduleName: String?,
-    val apiVersion: String?,
-    val languageVersion: String?,
-    val jvmTarget: String?,
-    val extraArguments: List<String>
-) {
-    fun intersect(other: PSourceRootKotlinOptions) = PSourceRootKotlinOptions(
-        if (noStdlib == other.noStdlib) noStdlib else null,
-        if (noReflect == other.noReflect) noReflect else null,
-        if (moduleName == other.moduleName) moduleName else null,
-        if (apiVersion == other.apiVersion) apiVersion else null,
-        if (languageVersion == other.languageVersion) languageVersion else null,
-        if (jvmTarget == other.jvmTarget) jvmTarget else null,
-        extraArguments.intersect(other.extraArguments).toList()
-    )
-}
-
-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(),
-    val originalName: String = name
-) {
-    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")
-    }
-
-    fun Project.matchesSelectedVariant(): Boolean {
-        val extension = this.extensions.findByType(PillExtension::class.java) ?: return true
-        val projectVariant = extension.variant.takeUnless { it == Variant.DEFAULT } ?: Variant.BASE
-        return projectVariant in context.variant.includes
-    }
-
-    val (includedProjects, excludedProjects) = project.allprojects
-        .partition { it.plugins.hasPlugin(JpsCompatiblePlugin::class.java) && it.matchesSelectedVariant() }
-
-    val modules = includedProjects.flatMap { parseModules(it, excludedProjects) }
-
-    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("runtimeClasspath") to Scope.RUNTIME,
-    listOf("compile", "embedded") to Scope.COMPILE,
-    listOf("compileOnly") to Scope.PROVIDED
-)
-
-private val TEST_CONFIGURATION_MAPPING = mapOf(
-    listOf("runtimeClasspath", "testRuntimeClasspath") to Scope.RUNTIME,
-    listOf("compile", "testCompile") to Scope.COMPILE,
-    listOf("compileOnly", "testCompileOnly") to Scope.PROVIDED,
-    listOf("jpsTest") to Scope.TEST
-)
-
-private fun ParserContext.parseModules(project: Project, excludedProjects: List<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()
-
-    fun getPillExcludedDirs() = project.extensions.getByType(PillExtension::class.java).excludedDirs
-
-    val allExcludedDirs = getPillExcludedDirs() + getJavaExcludedDirs() + project.buildDir +
-            (if (project == project.rootProject) excludedProjects.map { it.buildDir } else emptyList())
-
-    var productionSourcesModule: PModule? = null
-
-    fun getModuleFile(suffix: String = ""): File {
-        val relativePath = File(project.projectDir, project.pillModuleName + 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.pillModuleName + ".src")
-            dependencies += POrderRoot(productionModuleDependency, Scope.COMPILE, true)
-        }
-
-        val module = PModule(
-            project.pillModuleName + nameSuffix,
-            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.rootProject.name + ".iml")
-        else -> getModuleFile()
-    }
-
-    modules += PModule(
-        project.pillModuleName,
-        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 kotlinTasksBySourceSet = project.tasks.names
-            .filter { it.startsWith("compile") && it.endsWith("Kotlin") }
-            .map { project.tasks.getByName(it) }
-            .associateBy { it.invokeInternal("getSourceSetName") }
-
-    val sourceRoots = mutableListOf<PSourceRoot>()
-
-    val sourceSets = project.sourceSets
-    if (sourceSets != null) {
-        for (sourceSet in sourceSets) {
-            val kotlinCompileTask = kotlinTasksBySourceSet[sourceSet.name]
-            val kind = if (sourceSet.isTestSourceSet) Kind.TEST else Kind.PRODUCTION
-
-            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
-
-            val kotlinOptions = kotlinCompileTask?.let { getKotlinOptions(it) }
-
-            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, kotlinOptions)
-            }
-
-            for (directory in directories) {
-                sourceRoots += PSourceRoot(directory, kind, kotlinOptions)
-            }
-
-            for (root in parseResourceRootsProcessedByProcessResourcesTask(project, sourceSet)) {
-                if (sourceRoots.none { it.path == root.path }) {
-                    sourceRoots += root
-                }
-            }
-        }
-    }
-
-    return sourceRoots
-}
-
-private fun parseResourceRootsProcessedByProcessResourcesTask(project: Project, sourceSet: SourceSet): List<PSourceRoot> {
-    val isMainSourceSet = sourceSet.name == SourceSet.MAIN_SOURCE_SET_NAME
-
-    val resourceRootKind = if (sourceSet.isTestSourceSet) PSourceRoot.Kind.TEST_RESOURCES else PSourceRoot.Kind.RESOURCES
-    val taskNameBase = "processResources"
-    val taskName = if (isMainSourceSet) taskNameBase else sourceSet.name + taskNameBase.capitalize()
-    val task = project.tasks.findByName(taskName) as? ProcessResources ?: return emptyList()
-
-    val roots = mutableListOf<File>()
-    fun collectRoots(spec: CopySpecInternal) {
-        if (spec is SingleParentCopySpec && spec.children.none()) {
-            roots += spec.sourcePaths.map { File(project.projectDir, it.toString()) }.filter { it.exists() }
-            return
-        }
-
-        spec.children.forEach(::collectRoots)
-    }
-    collectRoots(task.rootSpec)
-
-    return roots.map { PSourceRoot(it, resourceRootKind, null) }
-}
-
-private val SourceSet.isTestSourceSet: Boolean
-    get() = name == SourceSet.TEST_SOURCE_SET_NAME
-            || name.endsWith("Test")
-            || name.endsWith("Tests")
-
-private fun getKotlinOptions(kotlinCompileTask: Any): PSourceRootKotlinOptions? {
-    val compileArguments = run {
-        val method = kotlinCompileTask::class.java.getMethod("getSerializedCompilerArguments")
-        method.isAccessible = true
-        method.invoke(kotlinCompileTask) as List<String>
-    }
-
-    fun parseBoolean(name: String) = compileArguments.contains("-$name")
-    fun parseString(name: String) = compileArguments.dropWhile { it != "-$name" }.drop(1).firstOrNull()
-
-    fun isOptionForScriptingCompilerPlugin(option: String)
-            = option.startsWith("-Xplugin=") && option.contains("kotlin-scripting-compiler")
-
-    val extraArguments = compileArguments.filter {
-        it.startsWith("-X") && !isOptionForScriptingCompilerPlugin(it)
-    }
-
-    return PSourceRootKotlinOptions(
-            parseBoolean("no-stdlib"),
-            parseBoolean("no-reflect"),
-            parseString("module-name"),
-            parseString("api-version"),
-            parseString("language-version"),
-            parseString("jvm-target"),
-            extraArguments
-    )
-}
-
-private fun Any.invokeInternal(name: String, instance: Any = this): Any? {
-    val method = javaClass.methods.single { it.name.startsWith(name) && it.parameterTypes.isEmpty() }
-
-    val oldIsAccessible = method.isAccessible
-    try {
-        method.isAccessible = true
-        return method.invoke(instance)
-    } finally {
-        method.isAccessible = oldIsAccessible
-    }
-}
-
-private fun ParserContext.parseDependencies(project: Project, forTests: Boolean): List<POrderRoot> {
-    val configurations = project.configurations
-    val configurationMapping = if (forTests) TEST_CONFIGURATION_MAPPING else CONFIGURATION_MAPPING
-
-    val mainRoots = mutableListOf<POrderRoot>()
-    val deferredRoots = mutableListOf<POrderRoot>()
-
-    for ((configurationNames, scope) in configurationMapping) {
-        for (configurationName in configurationNames) {
-            val configuration = configurations.findByName(configurationName) ?: continue
-            val (main, deferred) = project.resolveDependencies(configuration, forTests, dependencyMappers)
-            mainRoots += main.map { POrderRoot(it, scope) }
-            deferredRoots += deferred.map { POrderRoot(it, scope) }
-        }
-    }
-
-    return removeDuplicates(mainRoots + deferredRoots)
-}
-
-fun removeDuplicates(roots: List<POrderRoot>): List<POrderRoot> {
-    val dependenciesByScope = roots.groupBy { it.scope }.mapValues { it.value.mapTo(mutableSetOf()) { it.dependency } }
-    fun dependenciesFor(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 dependenciesFor(Scope.COMPILE)) {
-            continue
-        }
-
-        if (scope == Scope.PROVIDED && dependency in dependenciesFor(Scope.RUNTIME)) {
-            result += POrderRoot(dependency, Scope.COMPILE)
-            continue
-        }
-
-        if (scope == Scope.RUNTIME && dependency in dependenciesFor(Scope.PROVIDED)) {
-            result += POrderRoot(dependency, Scope.COMPILE)
-            continue
-        }
-
-        result += root
-    }
-
-    return result.toList()
-}
-
-val Project.pillModuleName: String
-    get() = path.removePrefix(":").replace(':', '.')
-
-val Project.sourceSets: SourceSetContainer?
-    get() {
-        val convention = project.convention.findPlugin(JavaPluginConvention::class.java) ?: return null
-        return convention.sourceSets
-    }

buildSrc/src/main/kotlin/pill/pathContext.kt

@@ -1,54 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-package org.jetbrains.kotlin.pill
-
-import org.gradle.api.Project
-import java.io.File
-
-private val USER_HOME_DIR_PATH = System.getProperty("user.home").withSlash()
-
-private fun replacePrefix(path: String, prefix: String, variableName: String): String {
-    if (path.startsWith(prefix)) {
-        return "$" + variableName + "$/" + path.drop(prefix.length)
-    }
-
-    return path
-}
-
-private fun simplifyUserHomeDirPath(path: String): String {
-    return replacePrefix(path, USER_HOME_DIR_PATH, "USER_HOME")
-}
-
-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(private val projectDir: File) : PathContext {
-    constructor(project: PProject) : this(project.rootDirectory)
-    constructor(project: Project) : this(project.projectDir)
-
-    override fun invoke(file: File): String {
-        return simplifyUserHomeDirPath(replacePrefix(file.absolutePath, projectDir.absolutePath.withSlash(), "PROJECT_DIR"))
-    }
-}
-
-class ModuleContext(val project: PProject, val module: PModule) : PathContext {
-    override fun invoke(file: File): String {
-        if (!file.startsWith(project.rootDirectory)) {
-            return simplifyUserHomeDirPath(file.absolutePath)
-        }
-
-        return "\$MODULE_DIR\$/" + file.toRelativeString(module.moduleFile.parentFile)
-    }
-}
-
-fun String.withSlash() = if (this.endsWith("/")) this else (this + "/")
-fun String.withoutSlash() = this.trimEnd('/')

buildSrc/src/main/kotlin/pill/plugin.kt

@@ -1,336 +0,0 @@
-@file:Suppress("PackageDirectoryMismatch")
-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 PillConfigurablePlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        project.configurations.maybeCreate(EmbeddedComponents.CONFIGURATION_NAME)
-        project.extensions.create("pill", PillExtension::class.java)
-    }
-}
-
-class JpsCompatiblePlugin : Plugin<Project> {
-    companion object {
-        private fun getDependencyMappers(projectLibraries: List<PLibrary>): List<DependencyMapper> {
-            val mappersForKotlinLibrariesExeptStdlib = projectLibraries
-                .filter { it.name != "kotlin-stdlib" }
-                .map { DependencyMapper.forProject(it.originalName) { MappedDependency(PDependency.Library(it.name)) } }
-
-            val disabledModuleMappers = listOf(
-                ":kotlin-stdlib-common",
-                ":core:builtins",
-                ":kotlin-compiler",
-                ":kotlin-compiler-embeddable",
-                ":kotlin-test:kotlin-test-common",
-                ":kotlin-test:kotlin-test-annotations-common"
-            ).map { DependencyMapper.forProject(it) { null } }
-
-            return listOf(
-                DependencyMapper.forProject(":kotlin-stdlib") {
-                    MappedDependency(
-                        PDependency.Library("kotlin-stdlib"),
-                        listOf(PDependency.Library("annotations-13.0"))
-                    )
-                },
-                DependencyMapper.forProject(":kotlin-test:kotlin-test-jvm") { MappedDependency(PDependency.Library("kotlin-test-jvm")) },
-                DependencyMapper.forProject(":kotlin-reflect-api") { MappedDependency(PDependency.Library("kotlin-reflect")) }
-            ) + mappersForKotlinLibrariesExeptStdlib + disabledModuleMappers
-        }
-
-        fun getProjectLibraries(rootProject: Project): List<PLibrary> {
-            val distLibDir = File(rootProject.extra["distLibDir"].toString())
-            fun distJar(name: String) = File(rootProject.projectDir, "dist/kotlinc/lib/$name.jar")
-
-            val libraries = rootProject.allprojects
-                .mapNotNull { library ->
-                    val libraryExtension = library.extensions.findByType(PillExtension::class.java)
-                            ?.takeIf { it.importAsLibrary }
-                            ?: return@mapNotNull null
-
-                    val libraryPath = libraryExtension.libraryPath ?: distLibDir
-                    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(),
-                        originalName = library.path
-                    )
-                }
-
-            return libraries + PLibrary("annotations-13.0", classes = listOf(distJar("annotations-13.0")))
-        }
-    }
-
-    override fun apply(project: Project) {
-        project.plugins.apply(PillConfigurablePlugin::class.java)
-        // 'jpsTest' does not require the 'tests-jar' artifact
-        project.configurations.create("jpsTest")
-
-        if (project == project.rootProject) {
-            project.tasks.create("pill") {
-                doLast { pill(project) }
-
-                if (System.getProperty("pill.android.tests", "false") == "true") {
-                    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 var isAndroidStudioPlatform: Boolean = false
-
-    private fun initEnvironment(project: Project) {
-        projectDir = project.projectDir
-        platformVersion = project.extensions.extraProperties.get("versions.intellijSdk").toString()
-        platformBaseNumber = platformVersion.substringBefore(".", "").takeIf { it.isNotEmpty() }
-            ?: platformVersion.substringBefore("-", "").takeIf { it.isNotEmpty() }
-            ?: error("Invalid platform version: $platformVersion")
-        platformDir = IntellijRootUtils.getIntellijRootDir(project)
-        isAndroidStudioPlatform = project.extensions.extraProperties.has("versions.androidStudioRelease")
-    }
-
-    private fun pill(rootProject: Project) {
-        initEnvironment(rootProject)
-
-        val variantOptionValue = System.getProperty("pill.variant", "base").toUpperCase()
-        val variant = PillExtension.Variant.values().firstOrNull { it.name == variantOptionValue }
-                ?: run {
-                    rootProject.logger.error("Invalid variant name: $variantOptionValue")
-                    return
-                }
-
-        rootProject.logger.lifecycle("Pill: Setting up project for the '${variant.name.toLowerCase()}' variant...")
-
-        if (variant == PillExtension.Variant.NONE || variant == PillExtension.Variant.DEFAULT) {
-            rootProject.logger.error("'none' and 'default' should not be passed as a Pill variant property value")
-            return
-        }
-
-        val projectLibraries = getProjectLibraries(rootProject)
-        val dependencyMappers = getDependencyMappers(projectLibraries)
-
-        val parserContext = ParserContext(dependencyMappers, variant)
-
-        val jpsProject = parse(rootProject, projectLibraries, parserContext)
-            .mapLibraries(this::attachPlatformSources, this::attachAsmSources)
-
-        val files = render(jpsProject)
-
-        removeExistingIdeaLibrariesAndModules()
-        removeJpsAndPillRunConfigurations()
-        removeAllArtifactConfigurations()
-
-        generateKotlinPluginArtifactFile(rootProject, dependencyMappers).write()
-
-        copyRunConfigurations()
-        setOptionsForDefaultJunitRunConfiguration(rootProject)
-
-        files.forEach { it.write() }
-    }
-
-    private fun unpill(project: Project) {
-        initEnvironment(project)
-
-        removeExistingIdeaLibrariesAndModules()
-        removeJpsAndPillRunConfigurations()
-        removeAllArtifactConfigurations()
-    }
-
-    private fun removeExistingIdeaLibrariesAndModules() {
-        File(projectDir, ".idea/libraries").deleteRecursively()
-        File(projectDir, ".idea/modules").deleteRecursively()
-    }
-
-    private fun removeJpsAndPillRunConfigurations() {
-        File(projectDir, ".idea/runConfigurations")
-            .walk()
-            .filter { (it.name.startsWith("JPS_") || it.name.startsWith("Pill_")) && it.extension.toLowerCase() == "xml" }
-            .forEach { it.delete() }
-    }
-
-    private fun removeAllArtifactConfigurations() {
-        File(projectDir, ".idea/artifacts")
-            .walk()
-            .filter { 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)
-        val additionalIdeaArgs = if (isAndroidStudioPlatform) "-Didea.platform.prefix=AndroidStudio" else ""
-
-        targetDir.mkdirs()
-
-        fun substitute(text: String): String {
-            return text
-                .replace("\$IDEA_HOME_PATH\$", platformDirProjectRelative)
-                .replace("\$ADDITIONAL_IDEA_ARGS\$", additionalIdeaArgs)
-        }
-
-        runConfigurationsDir.listFiles()
-            .filter { it.extension == "xml" }
-            .map { it.name to substitute(it.readText()) }
-            .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?) {
-                    val optionsWithoutNewValue = options.filter { !it.startsWith("-D$name=") }
-                    options = if (value == null) optionsWithoutNewValue else (optionsWithoutNewValue + listOf("-D$name=$value"))
-                }
-
-                val robolectricClasspath = project.rootProject
-                    .project(":plugins:android-extensions-compiler")
-                    .configurations.getByName("robolectricClasspath")
-                    .files.joinToString(File.pathSeparator)
-
-                if (options.none { it == "-ea" }) {
-                    options += "-ea"
-                }
-
-                addOrReplaceOptionValue("idea.home.path", platformDirProjectRelative)
-                addOrReplaceOptionValue("ideaSdk.androidPlugin.path", platformDirProjectRelative + "/plugins/android/lib")
-                addOrReplaceOptionValue("robolectric.classpath", robolectricClasspath)
-                addOrReplaceOptionValue("use.jps", "true")
-                addOrReplaceOptionValue("kotlinVersion", project.rootProject.extra["kotlinVersion"].toString())
-
-                val isAndroidStudioBunch = project.findProperty("versions.androidStudioRelease") != null
-                addOrReplaceOptionValue("idea.platform.prefix", if (isAndroidStudioBunch) "AndroidStudio" else null)
-
-                val androidJarPath = project.configurations.findByName("androidJar")?.singleFile
-                val androidSdkPath = project.configurations.findByName("androidSdk")?.singleFile
-
-                if (androidJarPath != null && androidSdkPath != null) {
-                    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/intellij-$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)
-    }
-}

buildSrc/src/main/kotlin/pill/render.kt

@@ -1,200 +0,0 @@
-@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)
-                    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)
-        }
-
-        val kotlinCompileOptionsList = module.contentRoots.flatMap { it.sourceRoots }.mapNotNull { it.kotlinOptions }
-        var kotlinCompileOptions = kotlinCompileOptionsList.firstOrNull()
-        for (otherOptions in kotlinCompileOptionsList.drop(1)) {
-            kotlinCompileOptions = kotlinCompileOptions?.intersect(otherOptions)
-        }
-
-        val pathContext = ModuleContext(project, module)
-
-        val platformVersion = (kotlinCompileOptions?.jvmTarget ?: "1.8")
-        val classesDirectory = File(project.rootDirectory, "out/production/${module.name}")
-
-        if (kotlinCompileOptions != null) {
-            xml("component", "name" to "FacetManager") {
-                xml("facet", "type" to "kotlin-language", "name" to "Kotlin") {
-                    xml("configuration", "version" to 3, "platform" to "JVM $platformVersion", "useProjectSettings" to "false") {
-                        xml("compilerSettings") {
-                            xml(
-                                "option",
-                                "name" to "additionalArguments",
-                                "value" to kotlinCompileOptions.extraArguments.joinToString(" ")
-                            )
-                        }
-                        xml("compilerArguments") {
-                            xml("option", "name" to "destination", "value" to pathContext(classesDirectory))
-
-                            fun Any?.option(name: String) {
-                                if (this != null) xml("option", "name" to name, "value" to this.toString())
-                            }
-
-                            kotlinCompileOptions.noStdlib.option("noStdlib")
-                            kotlinCompileOptions.noReflect.option("noReflect")
-                            module.name.option("moduleName")
-                            xml("option", "name" to "jvmTarget", "value" to platformVersion)
-                            kotlinCompileOptions.languageVersion.option("languageVersion")
-                            kotlinCompileOptions.apiVersion.option("apiVersion")
-
-                            xml("option", "name" to "pluginOptions") { xml("array") }
-                            xml("option", "name" to "pluginClasspaths") { xml("array") }
-                        }
-                    }
-                }
-            }
-        }
-
-        xml("component",
-            "name" to "NewModuleRootManager",
-            "LANGUAGE_LEVEL" to "JDK_${platformVersion.replace('.', '_')}",
-            "inherit-compiler-output" to "true"
-        ) {
-            xml("exclude-output")
-
-            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")
-
-            xml("orderEntry", "type" to "sourceFolder", "forTests" to "false")
-
-            for (orderRoot in module.orderRoots) {
-                val dependency = orderRoot.dependency
-
-                val args = when (dependency) {
-                    is PDependency.ModuleLibrary -> mutableListOf(
-                        "type" to "module-library"
-                    )
-                    is PDependency.Module -> mutableListOf(
-                        "type" to "module",
-                        "module-name" to dependency.name
-                    )
-                    is PDependency.Library -> mutableListOf(
-                        "type" to "library",
-                        "name" to dependency.name,
-                        "level" to "project"
-                    )
-                }
-
-                if (orderRoot.scope != POrderRoot.Scope.COMPILE) {
-                    args.add(1, "scope" to orderRoot.scope.toString())
-                }
-
-                if (dependency is PDependency.Module && orderRoot.isProductionOnTestDependency) {
-                    args += ("production-on-test" to "")
-                }
-
-                if (orderRoot.isExported) {
-                    args += ("exported" to "")
-                }
-
-                xml("orderEntry", *args.toTypedArray()) {
-                    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

buildSrc/src/main/kotlin/pill/xml.kt

@@ -1,61 +0,0 @@
-@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, private 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)
-    }
-}

buildSrc/src/main/kotlin/plugins/PublishedKotlinModule.kt

@@ -4,9 +4,10 @@ import org.codehaus.groovy.runtime.InvokerHelper
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.maven.Conf2ScopeMappingContainer
 import org.gradle.api.artifacts.maven.MavenDeployment
 import org.gradle.api.artifacts.maven.MavenResolver
-
+import org.gradle.api.plugins.MavenPluginConvention
 import org.gradle.api.plugins.MavenRepositoryHandlerConvention
 import org.gradle.api.publication.maven.internal.deployer.MavenRemoteRepository
 import org.gradle.api.tasks.Upload
@@ -30,6 +31,12 @@ open class PublishedKotlinModule : Plugin<Project> {
 
             plugins.apply("maven")
 
+            val publishedRuntime by configurations.creating {
+                the<MavenPluginConvention>()
+                    .conf2ScopeMappings
+                    .addMapping(0, this, Conf2ScopeMappingContainer.RUNTIME)
+            }
+
             if (!project.hasProperty("prebuiltJar")) {
                 plugins.apply("signing")
 
@@ -41,7 +48,7 @@ open class PublishedKotlinModule : Plugin<Project> {
                     sign(configurations["archives"])
                 }
 
-                (tasks.getByName("signArchives") as Sign).apply {
+                tasks.named<Sign>("signArchives").configure {
                     enabled = signingRequired
                 }
             }
@@ -98,9 +105,9 @@ open class PublishedKotlinModule : Plugin<Project> {
                 }
             }
 
-            val preparePublication = project.rootProject.tasks.getByName("preparePublication")
+            tasks.named<Upload>("uploadArchives").configure {
 
-            val uploadArchives = (tasks.getByName("uploadArchives") as Upload).apply {
+                val preparePublication = project.rootProject.tasks.named("preparePublication").get()
 
                 dependsOn(preparePublication)
 
@@ -152,8 +159,8 @@ open class PublishedKotlinModule : Plugin<Project> {
                 }
             }
 
-            tasks.create("publish") {
-                dependsOn(uploadArchives)
+            tasks.register("publish") {
+                dependsOn(tasks.named("uploadArchives"))
             }
         }
     }

buildSrc/src/main/kotlin/publish.kt

@@ -0,0 +1,25 @@
+import org.gradle.api.Action
+import org.gradle.api.NamedDomainObjectContainer
+import org.gradle.api.NamedDomainObjectProvider
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.ExternalModuleDependency
+import org.gradle.api.artifacts.dsl.DependencyHandler
+import org.gradle.kotlin.dsl.accessors.runtime.addDependencyTo
+
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+val NamedDomainObjectContainer<Configuration>.publishedRuntime: NamedDomainObjectProvider<Configuration> get() = named("publishedRuntime")
+
+fun DependencyHandler.publishedRuntime(dependencyNotation: Any): Dependency? =
+    add("publishedRuntime", dependencyNotation)
+
+fun DependencyHandler.publishedRuntime(
+    dependencyNotation: String,
+    dependencyConfiguration: Action<ExternalModuleDependency>
+): ExternalModuleDependency =
+    addDependencyTo(this, "publishedRuntime", dependencyNotation, dependencyConfiguration)
+

buildSrc/src/main/kotlin/sourceSets.kt

@@ -1,4 +1,5 @@
 import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.SourceSetContainer
 
@@ -37,7 +38,13 @@ val Project.sourceSets: SourceSetContainer
     get() = javaPluginConvention().sourceSets
 
 val Project.mainSourceSet: SourceSet
-    get() = sourceSets.getByName("main")
+    get() = javaPluginConvention().mainSourceSet
 
 val Project.testSourceSet: SourceSet
+    get() = javaPluginConvention().testSourceSet
+
+val JavaPluginConvention.mainSourceSet: SourceSet
+    get() = sourceSets.getByName("main")
+
+val JavaPluginConvention.testSourceSet: SourceSet
     get() = sourceSets.getByName("test")

buildSrc/src/main/kotlin/stripMetadata.kt

@@ -5,14 +5,17 @@ import org.jetbrains.org.objectweb.asm.*
 import java.io.BufferedOutputStream
 import java.io.File
 import java.io.FileOutputStream
+import java.util.*
 import java.util.jar.JarFile
 import java.util.zip.ZipEntry
 import java.util.zip.ZipOutputStream
 
+private val CONSTANT_TIME_FOR_ZIP_ENTRIES = GregorianCalendar(1980, 1, 1, 0, 0, 0).timeInMillis
+
 /**
  * Removes @kotlin.Metadata annotations from compiled Kotlin classes
  */
-fun stripMetadata(logger: Logger, classNamePattern: String, inFile: File, outFile: File) {
+fun stripMetadata(logger: Logger, classNamePattern: String, inFile: File, outFile: File, preserveFileTimestamps: Boolean = true) {
     val classRegex = classNamePattern.toRegex()
 
     assert(inFile.exists()) { "Input file not found at $inFile" }
@@ -49,6 +52,9 @@ fun stripMetadata(logger: Logger, classNamePattern: String, inFile: File, outFil
                 }
 
                 val newEntry = ZipEntry(entry.name)
+                if (!preserveFileTimestamps) {
+                    newEntry.time = CONSTANT_TIME_FOR_ZIP_ENTRIES
+                }
                 outJar.putNextEntry(newEntry)
                 outJar.write(outBytes)
                 outJar.closeEntry()

buildSrc/src/main/kotlin/tasks.kt

@@ -21,10 +21,10 @@
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.internal.tasks.testing.filter.DefaultTestFilter
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.testing.Test
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
-import org.gradle.kotlin.dsl.task
 import java.io.File
 import java.lang.Character.isLowerCase
 import java.lang.Character.isUpperCase
@@ -36,9 +36,9 @@ fun Project.projectTest(
     parallel: Boolean = false,
     shortenTempRootName: Boolean = false,
     body: Test.() -> Unit = {}
-): Test = getOrCreateTask(taskName) {
+): TaskProvider<Test> = getOrCreateTask(taskName) {
     doFirst {
-        val commandLineIncludePatterns = (filter as? DefaultTestFilter)?.commandLineIncludePatterns ?: emptySet()
+        val commandLineIncludePatterns = (filter as? DefaultTestFilter)?.commandLineIncludePatterns ?: mutableSetOf()
         val patterns = filter.includePatterns + commandLineIncludePatterns
         if (patterns.isEmpty() || patterns.any { '*' in it }) return@doFirst
         patterns.forEach { pattern ->
@@ -100,6 +100,7 @@ fun Project.projectTest(
     maxHeapSize = "1600m"
     systemProperty("idea.is.unit.test", "true")
     systemProperty("idea.home.path", intellijRootDir().canonicalPath)
+    systemProperty("java.awt.headless", "true")
     environment("NO_FS_ROOTS_ACCESS_CHECK", "true")
     environment("PROJECT_CLASSES_DIRS", testSourceSet.output.classesDirs.asPath)
     environment("PROJECT_BUILD_DIR", buildDir)
@@ -134,15 +135,16 @@ fun Project.projectTest(
     if (parallel) {
         maxParallelForks =
             project.findProperty("kotlin.test.maxParallelForks")?.toString()?.toInt()
-                ?: Math.max(Runtime.getRuntime().availableProcessors() / 2, 1)
+                ?: Math.max(Runtime.getRuntime().availableProcessors() / if (kotlinBuildProperties.isTeamcityBuild) 2 else 4, 1)
     }
     body()
 }
 
 private inline fun String.isFirstChar(f: (Char) -> Boolean) = isNotEmpty() && f(first())
 
-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() }
+inline fun <reified T : Task> Project.getOrCreateTask(taskName: String, noinline body: T.() -> Unit): TaskProvider<T> =
+    if (tasks.names.contains(taskName)) tasks.named(taskName, T::class.java).apply { configure(body) }
+    else tasks.register(taskName, T::class.java, body)
 
 object TaskUtils {
     fun useAndroidSdk(task: Task) {