Added incremental cache format versioning.

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

@@ -51,6 +51,7 @@ import org.jetbrains.jet.compiler.runner.KotlinCompilerRunner.runK2JvmCompiler
 import org.jetbrains.jet.utils.keysToMap
 import org.jetbrains.jps.incremental.ModuleLevelBuilder.ExitCode.*
 import com.intellij.openapi.diagnostic.Logger
+import org.jetbrains.jet.lang.resolve.java.JvmAbi
 
 public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
     class object {
@@ -83,6 +84,16 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR
 
         val representativeTarget = chunk.representativeTarget()
 
+        val outputDir = representativeTarget.getOutputDir()
+
+        val dataManager = context.getProjectDescriptor().dataManager
+        val incrementalCaches = chunk.getTargets().keysToMap { dataManager.getStorage(it, IncrementalCacheStorageProvider) }
+
+        if (incrementalCaches.values().any { it -> it.isCacheVersionIncompatible() }) {
+            incrementalCaches.values().forEach { it.clean() }
+            return CHUNK_REBUILD_REQUIRED
+        }
+
         // For non-incremental build: take all sources
         if (!dirtyFilesHolder.hasDirtyFiles() && !dirtyFilesHolder.hasRemovedFiles()) {
             return NOTHING_DONE
@@ -94,11 +105,6 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR
 
         messageCollector.report(INFO, "Kotlin JPS plugin version " + KotlinVersion.VERSION, NO_LOCATION)
 
-        val outputDir = representativeTarget.getOutputDir()
-
-        val dataManager = context.getProjectDescriptor().dataManager
-        val incrementalCaches = chunk.getTargets().keysToMap { dataManager.getStorage(it, IncrementalCacheStorageProvider) }
-
         val compilerServices = Services.Builder()
                 .register(javaClass<IncrementalCacheProvider>(), IncrementalCacheProviderImpl(incrementalCaches))
                 .build()

jps-plugin/src/org/jetbrains/jet/jps/incremental/IncrementalCacheImpl.kt

@@ -40,15 +40,25 @@ import java.security.MessageDigest
 import org.jetbrains.jps.incremental.storage.StorageOwner
 import org.jetbrains.jps.builders.storage.StorageProvider
 import java.io.IOException
+import java.util.Scanner
+import org.jetbrains.jet.lang.resolve.java.JvmAbi
 
 val INLINE_ANNOTATION_DESC = "Lkotlin/inline;"
 
 public class IncrementalCacheImpl(val baseDir: File): StorageOwner, IncrementalCache {
     class object {
+        val DIRECTORY_NAME = "kotlin"
+
         val PROTO_MAP = "proto.tab"
         val CONSTANTS_MAP = "constants.tab"
         val INLINE_FUNCTIONS = "inline-functions.tab"
         val PACKAGE_PARTS = "package-parts.tab"
+
+        // Change this when incremental cache format changes
+        private val INCREMENTAL_CACHE_OWN_VERSION = 1
+        public val CACHE_FORMAT_VERSION: Int = INCREMENTAL_CACHE_OWN_VERSION * 1000000 + JvmAbi.VERSION
+
+        val FORMAT_VERSION_TXT = "format-version.txt"
     }
 
     private val protoMap = ProtoMap()
@@ -58,8 +68,34 @@ public class IncrementalCacheImpl(val baseDir: File): StorageOwner, IncrementalC
 
     private val maps = listOf(protoMap, constantsMap, inlineFunctionsMap, packagePartMap)
 
+    private fun getFormatVersionFile(): File {
+        return File(baseDir, FORMAT_VERSION_TXT)
+    }
+
+    public fun isCacheVersionIncompatible(): Boolean {
+        val version = loadCacheFormatVersion()
+        return version != -1 && version != CACHE_FORMAT_VERSION
+    }
+
+    private fun loadCacheFormatVersion(): Int {
+        val versionFile = getFormatVersionFile()
+        if (!versionFile.exists()) return -1
+
+        return versionFile.readText().toInt()
+    }
+
+    private fun saveCacheFormatVersionIfNeeded() {
+        val versionFile = getFormatVersionFile()
+        if (!versionFile.exists()) {
+            versionFile.writeText(CACHE_FORMAT_VERSION.toString())
+        }
+    }
+
     public fun saveFileToCache(sourceFiles: Collection<File>, classFile: File): RecompilationDecision {
         if (classFile.extension.toLowerCase() != "class") return DO_NOTHING
+        
+        saveCacheFormatVersionIfNeeded()
+
         val kotlinClass = LocalFileKotlinClass.create(classFile)
         if (kotlinClass == null) return DO_NOTHING
 
@@ -121,6 +157,7 @@ public class IncrementalCacheImpl(val baseDir: File): StorageOwner, IncrementalC
 
     public override fun clean() {
         maps.forEach { it.clean() }
+        getFormatVersionFile().delete()
     }
 
     public override fun close() {
@@ -457,7 +494,7 @@ public class IncrementalCacheImpl(val baseDir: File): StorageOwner, IncrementalC
 
 public object IncrementalCacheStorageProvider : StorageProvider<IncrementalCacheImpl>() {
     override fun createStorage(targetDataDir: File?): IncrementalCacheImpl {
-        return IncrementalCacheImpl(File(targetDataDir, "kotlin"))
+        return IncrementalCacheImpl(File(targetDataDir, IncrementalCacheImpl.DIRECTORY_NAME))
     }
 }