diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerReferenceIndex.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerReferenceIndex.java
index 61ca320b0898..8ce1276c008f 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerReferenceIndex.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerReferenceIndex.java
@@ -273,7 +273,8 @@ public class CompilerReferenceIndex<Input> {
                                            16 * 1024,
                                            false,
                                            true,
-                                           readOnly) {
+                                           readOnly,
+                                           null) {
       @Override
       public void checkCanceled() {
         //TODO
diff --git a/platform/lang-impl/src/com/intellij/util/indexing/VfsAwareMapIndexStorage.java b/platform/lang-impl/src/com/intellij/util/indexing/VfsAwareMapIndexStorage.java
index d410a6060cc3..f55c173e52f2 100644
--- a/platform/lang-impl/src/com/intellij/util/indexing/VfsAwareMapIndexStorage.java
+++ b/platform/lang-impl/src/com/intellij/util/indexing/VfsAwareMapIndexStorage.java
@@ -58,7 +58,7 @@ public final class VfsAwareMapIndexStorage<Key, Value> extends MapIndexStorage<K
                                  final int cacheSize,
                                  final boolean readOnly
   ) throws IOException {
-    super(storageFile, keyDescriptor, valueExternalizer, cacheSize, false, true, readOnly);
+    super(storageFile, keyDescriptor, valueExternalizer, cacheSize, false, true, readOnly, null);
     myBuildKeyHashToVirtualFileMapping = false;
   }
 
@@ -68,7 +68,7 @@ public final class VfsAwareMapIndexStorage<Key, Value> extends MapIndexStorage<K
                                  final int cacheSize,
                                  boolean keyIsUniqueForIndexedFile,
                                  boolean buildKeyHashToVirtualFileMapping) throws IOException {
-    super(storageFile, keyDescriptor, valueExternalizer, cacheSize, keyIsUniqueForIndexedFile, false, false);
+    super(storageFile, keyDescriptor, valueExternalizer, cacheSize, keyIsUniqueForIndexedFile, false, false, null);
     myBuildKeyHashToVirtualFileMapping = buildKeyHashToVirtualFileMapping;
     initMapAndCache();
   }
diff --git a/platform/util/src/com/intellij/util/indexing/impl/MapIndexStorage.java b/platform/util/src/com/intellij/util/indexing/impl/MapIndexStorage.java
index 0b8d1b2ca6ad..d9240c96219f 100644
--- a/platform/util/src/com/intellij/util/indexing/impl/MapIndexStorage.java
+++ b/platform/util/src/com/intellij/util/indexing/impl/MapIndexStorage.java
@@ -17,6 +17,7 @@ package com.intellij.util.indexing.impl;
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.util.IncorrectOperationException;
+import com.intellij.util.IntIntFunction;
 import com.intellij.util.Processor;
 import com.intellij.util.containers.SLRUCache;
 import com.intellij.util.indexing.StorageException;
@@ -44,13 +45,14 @@ public abstract class MapIndexStorage<Key, Value> implements IndexStorage<Key, V
   private final DataExternalizer<Value> myDataExternalizer;
   private final boolean myKeyIsUniqueForIndexedFile;
   private final boolean myReadOnly;
+  @Nullable private final IntIntFunction myInputRemapping;
 
   protected MapIndexStorage(@NotNull File storageFile,
                          @NotNull KeyDescriptor<Key> keyDescriptor,
                          @NotNull DataExternalizer<Value> valueExternalizer,
                          final int cacheSize,
                          boolean keyIsUniqueForIndexedFile) throws IOException {
-    this(storageFile, keyDescriptor, valueExternalizer, cacheSize, keyIsUniqueForIndexedFile, true, false);
+    this(storageFile, keyDescriptor, valueExternalizer, cacheSize, keyIsUniqueForIndexedFile, true, false, null);
   }
 
   protected MapIndexStorage(@NotNull File storageFile,
@@ -59,13 +61,20 @@ public abstract class MapIndexStorage<Key, Value> implements IndexStorage<Key, V
                             final int cacheSize,
                             boolean keyIsUniqueForIndexedFile,
                             boolean initialize,
-                            boolean readOnly) throws IOException {
+                            boolean readOnly,
+                            @Nullable IntIntFunction inputRemapping) throws IOException {
     myBaseStorageFile = storageFile;
     myKeyDescriptor = keyDescriptor;
     myCacheSize = cacheSize;
     myDataExternalizer = valueExternalizer;
     myKeyIsUniqueForIndexedFile = keyIsUniqueForIndexedFile;
     myReadOnly = readOnly;
+    if (inputRemapping != null) {
+      LOG.assertTrue(myReadOnly, "input remapping allowed only for read-only storage");
+    } else {
+      inputRemapping = IntIntFunction.IDENTITY;
+    }
+    myInputRemapping = inputRemapping;
     if (initialize) initMapAndCache();
   }
 
@@ -83,7 +92,7 @@ public abstract class MapIndexStorage<Key, Value> implements IndexStorage<Key, V
       PersistentHashMapValueStorage.CreationTimeOptions.HAS_NO_CHUNKS.set(Boolean.TRUE);
     }
     try {
-      map = new ValueContainerMap<Key, Value>(getStorageFile(), myKeyDescriptor, myDataExternalizer, myKeyIsUniqueForIndexedFile) {
+      map = new ValueContainerMap<Key, Value>(getStorageFile(), myKeyDescriptor, myDataExternalizer, myKeyIsUniqueForIndexedFile, myInputRemapping) {
         @Override
         protected boolean isReadOnly() {
           return myReadOnly;
diff --git a/platform/util/src/com/intellij/util/indexing/impl/ValueContainerImpl.java b/platform/util/src/com/intellij/util/indexing/impl/ValueContainerImpl.java
index 649d28d08696..0bd6d77b400c 100644
--- a/platform/util/src/com/intellij/util/indexing/impl/ValueContainerImpl.java
+++ b/platform/util/src/com/intellij/util/indexing/impl/ValueContainerImpl.java
@@ -17,6 +17,7 @@
 package com.intellij.util.indexing.impl;
 
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.util.IntIntFunction;
 import com.intellij.util.SmartList;
 import com.intellij.util.containers.EmptyIterator;
 import com.intellij.util.indexing.ValueContainer;
@@ -454,14 +455,16 @@ class ValueContainerImpl<Value> extends UpdatableValueContainer<Value> implement
 
   static final int NUMBER_OF_VALUES_THRESHOLD = 20;
 
-  public void readFrom(DataInputStream stream, DataExternalizer<? extends Value> externalizer) throws IOException {
+  public void readFrom(@NotNull DataInputStream stream,
+                       @NotNull DataExternalizer<? extends Value> externalizer,
+                       @NotNull IntIntFunction inputRemapping) throws IOException {
     FileId2ValueMapping<Value> mapping = null;
 
     while (stream.available() > 0) {
       final int valueCount = DataInputOutputUtil.readINT(stream);
       if (valueCount < 0) {
         // ChangeTrackingValueContainer marked inputId as invalidated, see ChangeTrackingValueContainer.saveTo
-        final int inputId = -valueCount;
+        final int inputId = inputRemapping.fun(-valueCount);
 
         if (mapping == null && size() > NUMBER_OF_VALUES_THRESHOLD) { // avoid O(NumberOfValues)
           mapping = new FileId2ValueMapping<>(this);
@@ -484,7 +487,7 @@ class ValueContainerImpl<Value> extends UpdatableValueContainer<Value> implement
 
           if (idCountOrSingleValue > 0) {
             addValue(idCountOrSingleValue, value);
-            if (mapping != null) mapping.associateFileIdToValue(idCountOrSingleValue, value);
+            if (mapping != null) mapping.associateFileIdToValue(inputRemapping.fun(idCountOrSingleValue), value);
           } else {
             idCountOrSingleValue = -idCountOrSingleValue;
             ChangeBufferingList changeBufferingList = ensureFileSetCapacityForValue(value, idCountOrSingleValue);
@@ -492,9 +495,10 @@ class ValueContainerImpl<Value> extends UpdatableValueContainer<Value> implement
 
             for (int i = 0; i < idCountOrSingleValue; i++) {
               final int id = DataInputOutputUtil.readINT(stream);
-              if (changeBufferingList != null)  changeBufferingList.add(prev + id);
-              else addValue(prev + id, value);
-              if (mapping != null) mapping.associateFileIdToValue(prev + id, value);
+              int remappedInputId = inputRemapping.fun(prev + id);
+              if (changeBufferingList != null) changeBufferingList.add(remappedInputId);
+              else addValue(remappedInputId, value);
+              if (mapping != null) mapping.associateFileIdToValue(remappedInputId, value);
               prev += id;
             }
           }
diff --git a/platform/util/src/com/intellij/util/indexing/impl/ValueContainerMap.java b/platform/util/src/com/intellij/util/indexing/impl/ValueContainerMap.java
index 1a8658f68ea1..66908255ee8c 100644
--- a/platform/util/src/com/intellij/util/indexing/impl/ValueContainerMap.java
+++ b/platform/util/src/com/intellij/util/indexing/impl/ValueContainerMap.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.util.indexing.impl;
 
+import com.intellij.util.IntIntFunction;
 import com.intellij.util.io.DataExternalizer;
 import com.intellij.util.io.KeyDescriptor;
 import com.intellij.util.io.PersistentHashMap;
@@ -32,8 +33,9 @@ class ValueContainerMap<Key, Value> extends PersistentHashMap<Key, UpdatableValu
   ValueContainerMap(@NotNull final File file,
                     @NotNull KeyDescriptor<Key> keyKeyDescriptor,
                     @NotNull DataExternalizer<Value> valueExternalizer,
-                    boolean keyIsUniqueForIndexedFile) throws IOException {
-    super(file, keyKeyDescriptor, new ValueContainerExternalizer<>(valueExternalizer));
+                    boolean keyIsUniqueForIndexedFile,
+                    @NotNull IntIntFunction inputRemapping) throws IOException {
+    super(file, keyKeyDescriptor, new ValueContainerExternalizer<>(valueExternalizer, inputRemapping));
     myValueExternalizer = valueExternalizer;
     myKeyIsUniqueForIndexedFile = keyIsUniqueForIndexedFile;
   }
@@ -68,9 +70,11 @@ class ValueContainerMap<Key, Value> extends PersistentHashMap<Key, UpdatableValu
 
   private static final class ValueContainerExternalizer<T> implements DataExternalizer<UpdatableValueContainer<T>> {
     @NotNull private final DataExternalizer<T> myValueExternalizer;
+    @NotNull private final IntIntFunction myInputRemapping;
 
-    private ValueContainerExternalizer(@NotNull DataExternalizer<T> valueExternalizer) {
+    private ValueContainerExternalizer(@NotNull DataExternalizer<T> valueExternalizer, @NotNull IntIntFunction inputRemapping) {
       myValueExternalizer = valueExternalizer;
+      myInputRemapping = inputRemapping;
     }
 
     @Override
@@ -83,7 +87,7 @@ class ValueContainerMap<Key, Value> extends PersistentHashMap<Key, UpdatableValu
     public UpdatableValueContainer<T> read(@NotNull final DataInput in) throws IOException {
       final ValueContainerImpl<T> valueContainer = new ValueContainerImpl<>();
 
-      valueContainer.readFrom((DataInputStream)in, myValueExternalizer);
+      valueContainer.readFrom((DataInputStream)in, myValueExternalizer, myInputRemapping);
       return valueContainer;
     }
   }