~~ try to fix KT-13079

#KT-13079 Fixed

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-2016 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,12 +36,13 @@ class CacheVersion(
         private val whenVersionChanged: CacheVersion.Action,
         private val whenTurnedOn: CacheVersion.Action,
         private val whenTurnedOff: CacheVersion.Action,
-        isEnabled: ()->Boolean
+        isEnabled: ()->Boolean,
+        val lock: Any? = null
 ) {
     private val isEnabled by lazy(isEnabled)
 
     private val actualVersion: Int
-        get() = versionFile.readText().toInt()
+        get() = syncReadVersion()
 
     private val expectedVersion: Int
         get() {
@@ -67,10 +68,53 @@ class CacheVersion(
             versionFile.parentFile.mkdirs()
         }
 
-        versionFile.writeText(expectedVersion.toString())
+        syncWriteVersion(expectedVersion)
+    }
+
+    private fun syncReadVersion(): Int {
+        if (lock == null) {
+            return readVersion()
+        }
+
+        synchronized(lock) {
+            return readVersion()
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun readVersion(): Int {
+        return versionFile.readText().toInt()
+    }
+
+    private fun syncWriteVersion(version: Int) {
+        if (lock == null) {
+            writeVersion(version)
+            return
+        }
+
+        synchronized(lock) {
+            writeVersion(version)
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun writeVersion(version: Int) {
+        versionFile.writeText(version.toString())
     }
 
     fun clean() {
+        if (lock == null) {
+            deleteVersionFile()
+            return
+        }
+
+        synchronized(lock) {
+            deleteVersionFile()
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun deleteVersionFile() {
         versionFile.delete()
     }
 
@@ -105,10 +149,11 @@ fun experimentalCacheVersion(dataRoot: File): CacheVersion =
                      whenTurnedOff = CacheVersion.Action.CLEAN_EXPERIMENTAL_CACHES,
                      isEnabled = { IncrementalCompilation.isExperimental() })
 
-fun dataContainerCacheVersion(dataRoot: File): CacheVersion =
+fun dataContainerCacheVersion(dataRoot: File, lock: Any?): CacheVersion =
         CacheVersion(ownVersion = DATA_CONTAINER_VERSION,
                      versionFile = File(dataRoot, DATA_CONTAINER_VERSION_FILE_NAME),
                      whenVersionChanged = CacheVersion.Action.REBUILD_ALL_KOTLIN,
                      whenTurnedOn = CacheVersion.Action.REBUILD_ALL_KOTLIN,
                      whenTurnedOff = CacheVersion.Action.CLEAN_DATA_CONTAINER,
-                     isEnabled = { IncrementalCompilation.isExperimental() })
+                     isEnabled = { IncrementalCompilation.isExperimental() },
+                     lock = lock)

jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt

@@ -113,7 +113,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
 
         if (targets.none { hasKotlin[it] == true }) return
 
-        val cacheVersionsProvider = CacheVersionProvider(dataManager.dataPaths)
+        val cacheVersionsProvider = CacheVersionProvider(context.projectDescriptor)
         val allVersions = cacheVersionsProvider.allVersions(targets)
         val actions = allVersions.map { it.checkVersion() }.toSet()
 
@@ -358,9 +358,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
     }
 
     private fun saveVersions(context: CompileContext, chunk: ModuleChunk) {
-        val dataManager = context.projectDescriptor.dataManager
         val targets = chunk.targets
-        val cacheVersionsProvider = CacheVersionProvider(dataManager.dataPaths)
+        val cacheVersionsProvider = CacheVersionProvider(context.projectDescriptor)
         cacheVersionsProvider.allVersions(targets).forEach { it.saveIfNeeded() }
     }
 

jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersionProvider.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-2016 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.jps.incremental
 
 import org.jetbrains.jps.builders.BuildTarget
 import org.jetbrains.jps.builders.storage.BuildDataPaths
+import org.jetbrains.jps.cmdline.ProjectDescriptor
 import org.jetbrains.jps.incremental.ModuleBuildTarget
 import org.jetbrains.kotlin.incremental.CacheVersion
 import org.jetbrains.kotlin.incremental.dataContainerCacheVersion
@@ -26,7 +27,9 @@ import org.jetbrains.kotlin.incremental.normalCacheVersion
 import java.io.File
 
 
-class CacheVersionProvider(private val paths: BuildDataPaths) {
+class CacheVersionProvider(val projectDescriptor: ProjectDescriptor) {
+    private val paths: BuildDataPaths = projectDescriptor.dataManager.dataPaths
+
     private val BuildTarget<*>.dataRoot: File
         get() = paths.getTargetDataRoot(this)
 
@@ -34,17 +37,17 @@ class CacheVersionProvider(private val paths: BuildDataPaths) {
 
     fun experimentalVersion(target: ModuleBuildTarget): CacheVersion = experimentalCacheVersion(target.dataRoot)
 
-    fun dataContainerVersion(): CacheVersion = dataContainerCacheVersion(KotlinDataContainerTarget.dataRoot)
+    fun dataContainerVersion(): CacheVersion = dataContainerCacheVersion(KotlinDataContainerTarget.dataRoot, projectDescriptor)
 
     fun allVersions(targets: Iterable<ModuleBuildTarget>): Iterable<CacheVersion> {
         val versions = arrayListOf<CacheVersion>()
-        versions.add(dataContainerCacheVersion(KotlinDataContainerTarget.dataRoot))
+        versions.add(dataContainerVersion())
 
-        for (dataRoot in targets.map { it.dataRoot }) {
-            versions.add(normalCacheVersion(dataRoot))
-            versions.add(experimentalCacheVersion(dataRoot))
+        for (target in targets) {
+            versions.add(normalVersion(target))
+            versions.add(experimentalVersion(target))
         }
 
         return versions
     }
-}
+}