Move back classes which used only in JPS

build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt

@@ -21,7 +21,6 @@ import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.EnumeratorStringDescriptor
 import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
-import gnu.trove.THashSet
 import java.io.DataInput
 import java.io.DataInputStream
 import java.io.DataOutput
@@ -46,25 +45,6 @@ object LookupSymbolKeyDescriptor : KeyDescriptor<LookupSymbolKey> {
     override fun isEqual(val1: LookupSymbolKey, val2: LookupSymbolKey): Boolean = val1 == val2
 }
 
-
-object PathFunctionPairKeyDescriptor : KeyDescriptor<PathFunctionPair> {
-    override fun read(input: DataInput): PathFunctionPair {
-        val path = IOUtil.readUTF(input)
-        val function = IOUtil.readUTF(input)
-        return PathFunctionPair(path, function)
-    }
-
-    override fun save(output: DataOutput, value: PathFunctionPair) {
-        IOUtil.writeUTF(output, value.path)
-        IOUtil.writeUTF(output, value.function)
-    }
-
-    override fun getHashCode(value: PathFunctionPair): Int = value.hashCode()
-
-    override fun isEqual(val1: PathFunctionPair, val2: PathFunctionPair): Boolean = val1 == val2
-}
-
-
 object ProtoMapValueExternalizer : DataExternalizer<ProtoMapValue> {
     override fun save(output: DataOutput, value: ProtoMapValue) {
         output.writeBoolean(value.isPackageFacade)
@@ -124,27 +104,6 @@ object StringToLongMapExternalizer : StringMapExternalizer<Long>() {
     }
 }
 
-
-object PathStringCollectionExternalizer : DataExternalizer<Collection<String>> {
-    override fun save(output: DataOutput, value: Collection<String>) {
-        for (str in value) {
-            IOUtil.writeUTF(output, str)
-        }
-    }
-
-    override fun read(input: DataInput): Collection<String> {
-        val result = THashSet(FileUtil.PATH_HASHING_STRATEGY)
-        val stream = input as DataInputStream
-
-        while (stream.available() > 0) {
-            val str = IOUtil.readUTF(stream)
-            result.add(str)
-        }
-
-        return result
-    }
-}
-
 object ConstantsMapExternalizer : DataExternalizer<Map<String, Any>> {
     override fun save(output: DataOutput, map: Map<String, Any>?) {
         output.writeInt(map!!.size)
@@ -228,7 +187,7 @@ object FileKeyDescriptor : KeyDescriptor<File> {
 
 open class CollectionExternalizer<T>(
         private val elementExternalizer: DataExternalizer<T>,
-        private val newCollection: ()->MutableCollection<T>
+        private val newCollection: () -> MutableCollection<T>
 ) : DataExternalizer<Collection<T>> {
     override fun read(input: DataInput): Collection<T> {
         val result = newCollection()

build/src/org/jetbrains/kotlin/incremental/storage/values.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.incremental.storage
 
-import com.intellij.openapi.util.io.FileUtil
-
 data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int) : Comparable<LookupSymbolKey> {
     constructor(name: String, scope: String) : this(name.hashCode(), scope.hashCode())
 
@@ -30,27 +28,4 @@ data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int) : Comparable<L
     }
 }
 
-class PathFunctionPair(
-        val path: String,
-        val function: String
-): Comparable<PathFunctionPair> {
-    override fun compareTo(other: PathFunctionPair): Int {
-        val pathComp = FileUtil.comparePaths(path, other.path)
-
-        if (pathComp != 0) return pathComp
-
-        return function.compareTo(other.function)
-    }
-
-    override fun equals(other: Any?): Boolean =
-            when (other) {
-                is PathFunctionPair ->
-                    FileUtil.pathsEqual(path, other.path) && function == other.function
-                else ->
-                    false
-            }
-
-    override fun hashCode(): Int = 31 * FileUtil.pathHashCode(path) + function.hashCode()
-}
-
 data class ProtoMapValue(val isPackageFacade: Boolean, val bytes: ByteArray, val strings: Array<String>)

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

@@ -25,9 +25,15 @@ import org.jetbrains.jps.incremental.storage.BuildDataManager
 import org.jetbrains.jps.incremental.storage.StorageOwner
 import org.jetbrains.kotlin.config.IncrementalCompilation
 import org.jetbrains.kotlin.incremental.*
-import org.jetbrains.kotlin.incremental.storage.*
+import org.jetbrains.kotlin.incremental.storage.BasicMap
+import org.jetbrains.kotlin.incremental.storage.BasicStringMap
+import org.jetbrains.kotlin.incremental.storage.StringCollectionExternalizer
+import org.jetbrains.kotlin.incremental.storage.StringToLongMapExternalizer
 import org.jetbrains.kotlin.inline.inlineFunctionsJvmNames
 import org.jetbrains.kotlin.jps.build.KotlinBuilder
+import org.jetbrains.kotlin.jps.incremental.storages.PathCollectionExternalizer
+import org.jetbrains.kotlin.jps.incremental.storages.PathFunctionPair
+import org.jetbrains.kotlin.jps.incremental.storages.PathFunctionPairKeyDescriptor
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.org.objectweb.asm.*
 import java.io.File
@@ -179,7 +185,7 @@ class JpsIncrementalCacheImpl(
      *  * inlineFunction - jvmSignature of some inline function in source file
      *  * target files - collection of files inlineFunction has been inlined to
      */
-    private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap<PathFunctionPair, Collection<String>>(storageFile, PathFunctionPairKeyDescriptor, PathStringCollectionExternalizer) {
+    private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap<PathFunctionPair, Collection<String>>(storageFile, PathFunctionPairKeyDescriptor, PathCollectionExternalizer) {
         fun add(sourcePath: String, jvmSignature: String, targetPath: String) {
             val key = PathFunctionPair(sourcePath, jvmSignature)
             storage.append(key, targetPath)

jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/externalizers.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.jps.incremental.storages
+
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.util.io.IOUtil
+import com.intellij.util.io.KeyDescriptor
+import gnu.trove.THashSet
+import org.jetbrains.jps.incremental.storage.PathStringDescriptor
+import org.jetbrains.kotlin.incremental.storage.CollectionExternalizer
+import java.io.DataInput
+import java.io.DataOutput
+
+object PathFunctionPairKeyDescriptor : KeyDescriptor<PathFunctionPair> {
+    override fun read(input: DataInput): PathFunctionPair {
+        val path = IOUtil.readUTF(input)
+        val function = IOUtil.readUTF(input)
+        return PathFunctionPair(path, function)
+    }
+
+    override fun save(output: DataOutput, value: PathFunctionPair) {
+        IOUtil.writeUTF(output, value.path)
+        IOUtil.writeUTF(output, value.function)
+    }
+
+    override fun getHashCode(value: PathFunctionPair): Int = value.hashCode()
+
+    override fun isEqual(val1: PathFunctionPair, val2: PathFunctionPair): Boolean = val1 == val2
+}
+
+object PathCollectionExternalizer : CollectionExternalizer<String>(PathStringDescriptor(), { THashSet(FileUtil.PATH_HASHING_STRATEGY) })

jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/values.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.jps.incremental.storages
+
+import com.intellij.openapi.util.io.FileUtil
+
+class PathFunctionPair(
+        val path: String,
+        val function: String
+): Comparable<PathFunctionPair> {
+    override fun compareTo(other: PathFunctionPair): Int {
+        val pathComp = FileUtil.comparePaths(path, other.path)
+
+        if (pathComp != 0) return pathComp
+
+        return function.compareTo(other.function)
+    }
+
+    override fun equals(other: Any?): Boolean =
+            when (other) {
+                is PathFunctionPair ->
+                    FileUtil.pathsEqual(path, other.path) && function == other.function
+                else ->
+                    false
+            }
+
+    override fun hashCode(): Int = 31 * FileUtil.pathHashCode(path) + function.hashCode()
+}