Migrate to new storage API.

Remove IncrementalPackageFragment::getMultifileFacade.

compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java

@@ -48,6 +48,9 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackageParts;
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider;
+import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache;
+import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents;
+import org.jetbrains.kotlin.modules.TargetId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.*;
@@ -221,7 +224,14 @@ public class PackageCodegen {
     private FieldOwnerContext getPackageFacadeContextForPreviouslyCompiled(@NotNull FqName delegateToFqName) {
         Type delegateToType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(delegateToFqName);
         String partInternalName = JvmClassName.byFqNameWithoutInnerClasses(delegateToFqName).getInternalName();
-        String facadeInternalName = compiledPackageFragment.getMultifileFacade(partInternalName);
+        TargetId targetId = state.getTargetId();
+        assert targetId != null
+                : "targetId is required for incremental compilation of " + packageClassType;
+        IncrementalCompilationComponents incrementalCompilationComponents = state.getIncrementalCompilationComponents();
+        assert incrementalCompilationComponents != null
+                : "incrementalCompilationComponents is required for incremental compilation of " + packageClassType;
+        IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId);
+        String facadeInternalName = incrementalCache.getMultifileFacade(partInternalName);
 
         Type publicFacadeType;
         if (facadeInternalName != null) {

compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt

@@ -25,7 +25,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapper
 
 public class KotlinToJvmSignatureMapperImpl : KotlinToJvmSignatureMapper {
     // We use empty BindingContext, because it is only used by JetTypeMapper for purposes irrelevant to the needs of this class
-    private val typeMapper: JetTypeMapper = JetTypeMapper(BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider)
+    private val typeMapper: JetTypeMapper = JetTypeMapper(
+            BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider, null)
 
     override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapSignature(function)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.load.java.descriptors.SamAdapterDescriptor
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider
+import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 
 private val EXTERNAL_SOURCES_KINDS = arrayOf(
         JvmDeclarationOriginKind.DELEGATION_TO_DEFAULT_IMPLS,
@@ -42,11 +43,12 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
         builderFactory: ClassBuilderFactory,
         bindingContext: BindingContext,
         private val diagnostics: DiagnosticSink,
-        fileClassesProvider: JvmFileClassesProvider
+        fileClassesProvider: JvmFileClassesProvider,
+        incrementalCache: IncrementalCache?
 ) : SignatureCollectingClassBuilderFactory(builderFactory) {
 
     // Avoid errors when some classes are not loaded for some reason
-    private val typeMapper = JetTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES, fileClassesProvider)
+    private val typeMapper = JetTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES, fileClassesProvider, incrementalCache)
 
     override fun handleClashingSignatures(data: ConflictingJvmDeclarationsData) {
         val noOwnImplementations = data.signatureOrigins.all { it.originKind in EXTERNAL_SOURCES_KINDS }

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.codegen.optimization.OptimizationClassBuilderFactory
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.FqName
@@ -86,10 +87,16 @@ public class GenerationState @JvmOverloads constructor(
 
     public val fileClassesProvider: CodegenFileClassesProvider = CodegenFileClassesProvider(packageFacadesAsMultifileClasses)
 
+    private fun getIncrementalCacheForThisTarget() =
+            if (incrementalCompilationComponents != null && targetId != null)
+                incrementalCompilationComponents.getIncrementalCache(targetId)
+            else null
+
     public val classBuilderMode: ClassBuilderMode = builderFactory.getClassBuilderMode()
     public val bindingTrace: BindingTrace = DelegatingBindingTrace(bindingContext, "trace in GenerationState")
     public val bindingContext: BindingContext = bindingTrace.getBindingContext()
-    public val typeMapper: JetTypeMapper = JetTypeMapper(this.bindingContext, classBuilderMode, fileClassesProvider)
+    public val typeMapper: JetTypeMapper = JetTypeMapper(this.bindingContext, classBuilderMode, fileClassesProvider,
+                                                         getIncrementalCacheForThisTarget())
     public val intrinsics: IntrinsicMethods = IntrinsicMethods()
     public val samWrapperClasses: SamWrapperClasses = SamWrapperClasses(this)
     public val inlineCycleReporter: InlineCycleReporter = InlineCycleReporter(diagnostics)
@@ -117,7 +124,8 @@ public class GenerationState @JvmOverloads constructor(
     init {
         val optimizationClassBuilderFactory = OptimizationClassBuilderFactory(builderFactory, disableOptimization)
         var interceptedBuilderFactory: ClassBuilderFactory = BuilderFactoryForDuplicateSignatureDiagnostics(
-                optimizationClassBuilderFactory, this.bindingContext, diagnostics, fileClassesProvider)
+                optimizationClassBuilderFactory, this.bindingContext, diagnostics, fileClassesProvider,
+                getIncrementalCacheForThisTarget())
 
         interceptedBuilderFactory = BuilderFactoryForDuplicateClassNameDiagnostics(interceptedBuilderFactory, diagnostics);
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageScope;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider;
+import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache;
 import org.jetbrains.kotlin.name.*;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetExpression;
@@ -85,15 +86,18 @@ public class JetTypeMapper {
     private final BindingContext bindingContext;
     private final ClassBuilderMode classBuilderMode;
     private final JvmFileClassesProvider fileClassesProvider;
+    private final IncrementalCache incrementalCache;
 
     public JetTypeMapper(
             @NotNull BindingContext bindingContext,
             @NotNull ClassBuilderMode classBuilderMode,
-            @NotNull JvmFileClassesProvider fileClassesProvider
+            @NotNull JvmFileClassesProvider fileClassesProvider,
+            @Nullable IncrementalCache incrementalCache
     ) {
         this.bindingContext = bindingContext;
         this.classBuilderMode = classBuilderMode;
         this.fileClassesProvider = fileClassesProvider;
+        this.incrementalCache = incrementalCache;
     }
 
     @NotNull
@@ -191,7 +195,7 @@ public class JetTypeMapper {
     }
 
     @Nullable
-    private static String getPackageMemberOwnerInternalName(@NotNull DeserializedCallableMemberDescriptor descriptor, boolean isImplementation) {
+    private String getPackageMemberOwnerInternalName(@NotNull DeserializedCallableMemberDescriptor descriptor, boolean isImplementation) {
         // XXX This method (and getPackageMemberOwnerShortName) is a dirty hack
         // introduced to make stdlib work with package facades built as multifile facades for M13.
         // We need some safe, concise way to identify multifile facade and multifile part
@@ -214,7 +218,7 @@ public class JetTypeMapper {
     }
 
     @Nullable
-    private static String getPackageMemberOwnerShortName(@NotNull DeserializedCallableMemberDescriptor descriptor, boolean isImplementation) {
+    private String getPackageMemberOwnerShortName(@NotNull DeserializedCallableMemberDescriptor descriptor, boolean isImplementation) {
         // XXX Dirty hack; see getPackageMemberOwnerInternalName above for more details.
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
         if (containingDeclaration instanceof PackageFragmentDescriptor) {
@@ -235,11 +239,12 @@ public class JetTypeMapper {
                 return PackageClassUtils.getPackageClassFqName(packageFragmentDescriptor.getFqName()).shortName().asString();
             }
             else if (packageFragmentDescriptor instanceof IncrementalPackageFragmentProvider.IncrementalPackageFragment) {
-                IncrementalPackageFragmentProvider.IncrementalPackageFragment incrementalPackageFragment =
-                        (IncrementalPackageFragmentProvider.IncrementalPackageFragment) packageFragmentDescriptor;
+                assert incrementalCache != null : "IncrementalPackageFragment found outside of incremental compilation context " +
+                                                  "for " + descriptor + " in package " + packageFragmentDescriptor;
+
                 String implClassInternalName = internalNameByFqNameWithoutInnerClasses(
                         packageFragmentDescriptor.getFqName().child(implClassName));
-                String facadeClassInternalName = incrementalPackageFragment.getMultifileFacade(implClassInternalName);
+                String facadeClassInternalName = incrementalCache.getMultifileFacade(implClassInternalName);
                 if (facadeClassInternalName == null) {
                     return implClassName.asString();
                 }

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
-import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
@@ -36,7 +35,6 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.serialization.PackageData
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
@@ -143,10 +141,6 @@ public class IncrementalPackageFragmentProvider(
             return IncrementalMultifileClassPackageFragment(multifileClassFqName, partsNames)
         }
 
-        public fun getMultifileFacade(partInternalName: String): String? {
-            return incrementalCache.getMultifileFacade(partInternalName)
-        }
-
         override fun getMemberScope(): JetScope = memberScope()
 
         public inner class IncrementalMultifileClassPackageFragment(

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

@@ -559,7 +559,7 @@ public class IncrementalCacheImpl(
 
     private inner class MultifileClassFacadeMap(storageFile: File) : BasicStringMap<List<String>>(storageFile, StringListExternalizer) {
         public fun add(facadeName: JvmClassName, partNames: List<String>) {
-            storage.put(facadeName.internalName, partNames)
+            storage[facadeName.internalName] = partNames
         }
 
         public fun getMultifileClassParts(facadeName: String): List<String>? = storage[facadeName]
@@ -573,7 +573,7 @@ public class IncrementalCacheImpl(
 
     private inner class MultifileClassPartMap(storageFile: File) : BasicStringMap<String>(storageFile, EnumeratorStringDescriptor.INSTANCE) {
         public fun add(partName: String, facadeName: String) {
-            storage.put(partName, facadeName)
+            storage[partName] = facadeName
         }
 
         public fun getFacadeName(partName: String): String? {
@@ -614,7 +614,8 @@ public class IncrementalCacheImpl(
         public fun getDirtyOutputClasses(): Collection<String> =
                 storage.keys
 
-        public fun isDirty(className: String): Boolean = storage.containsMapping(className)
+        public fun isDirty(className: String): Boolean =
+                storage.contains(className)
 
         override fun dumpValue(value: Boolean) = ""
     }