JvmName annotation support, single-file facade case (just rename file facade class)

- initial implementation of JvmFileClassesProvider
- migrate some of PackagePartClassUtil usages to JvmFileClassesProvider (mostly in Codegen)
- placeholder ("no resolve") implementation for migration period and unclear cases
- tests

compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenFileClassesProvider.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2010-2015 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.codegen
+
+import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.BindingContext
+import java.util.*
+
+public class CodegenFileClassesProvider private constructor(private val bindingContext: BindingContext) : JvmFileClassesProvider() {
+    private val fileParts = hashMapOf<JetFile, JvmFileClassInfo>()
+
+    override fun getFileClassFqName(file: JetFile): FqName =
+            getFileClassInfo(file).fileClassFqName
+
+    public fun getFileClassInfo(file: JetFile): JvmFileClassInfo =
+            fileParts.getOrPut(file) { createFileClassInfo(file) }
+
+    private fun createFileClassInfo(file: JetFile): JvmFileClassInfo {
+        val fileAnnotations = JvmFileClassUtil.collectFileAnnotations(file, bindingContext)
+        val jvmClassNameAnnotation = JvmFileClassUtil.parseJvmFileClass(fileAnnotations)
+        return JvmFileClassUtil.getFileClassInfo(file, jvmClassNameAnnotation)
+    }
+
+    internal fun addFileClassInfo(file: JetFile) {
+        if (fileParts.containsKey(file)) return
+        fileParts[file] = createFileClassInfo(file)
+    }
+
+    companion object {
+        public @jvmStatic fun createForCodegenTask(
+                bindingContext: BindingContext,
+                files: Collection<JetFile>,
+                packagesWithObsoleteParts: Collection<FqName>,
+                multifileFacadesWithObsoleteParts: Collection<FqName>
+        ) : CodegenFileClassesProvider {
+            val codegenFileClassesManager = CodegenFileClassesProvider(bindingContext)
+            files.forEach {
+                codegenFileClassesManager.addFileClassInfo(it)
+            }
+
+            val packagesToProcess = HashSet<FqName>(packagesWithObsoleteParts)
+            packagesToProcess.addAll(multifileFacadesWithObsoleteParts.map { it.parent() })
+            for (packageFqName in packagesToProcess) {
+                bindingContext.get(BindingContext.PACKAGE_TO_FILES, packageFqName)?.forEach {
+                    codegenFileClassesManager.addFileClassInfo(it)
+                }
+            }
+
+            return codegenFileClassesManager
+        }
+    }
+}
+
+public class JvmMultifileFacadeClassInfo(public val facadeFqName: FqName, public val fileParts: List<JvmFileClassInfo>)

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

@@ -44,7 +44,7 @@ public class KotlinCodegenFacade {
 
                 FqName name = ScriptNameUtil.classNameForScript(script);
                 Type type = AsmUtil.asmTypeByFqNameWithoutInnerClasses(name);
-                registerClassNameForScript(state.getBindingTrace(), script, type);
+                registerClassNameForScript(state.getBindingTrace(), script, type, state.getFileClassesManager());
             }
         }
 

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

@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JvmAbi;
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.*;
@@ -74,6 +74,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
     protected final PropertyCodegen propertyCodegen;
     protected final JetTypeMapper typeMapper;
     protected final BindingContext bindingContext;
+    protected final JvmFileClassesProvider fileClassesManager;
     private final MemberCodegen<?> parentCodegen;
     private final ReifiedTypeParametersUsages reifiedTypeParametersUsages = new ReifiedTypeParametersUsages();
     protected final Collection<ClassDescriptor> innerClasses = new LinkedHashSet<ClassDescriptor>();
@@ -94,6 +95,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         this.state = state;
         this.typeMapper = state.getTypeMapper();
         this.bindingContext = state.getBindingContext();
+        this.fileClassesManager = state.getFileClassesManager();
         this.element = element;
         this.context = context;
         this.v = builder;
@@ -288,7 +290,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
             return typeMapper.mapType(((ClassContext) outermost).getContextDescriptor());
         }
         else if (outermost instanceof PackageContext && !(outermost instanceof PackageFacadeContext)) {
-            return PackagePartClassUtils.getPackagePartType(element.getContainingJetFile());
+            return fileClassesManager.getFileClassType(element.getContainingJetFile());
         }/*disabled cause of KT-7775
         else if (outermost instanceof ScriptContext) {
             return asmTypeForScriptDescriptor(bindingContext, ((ScriptContext) outermost).getScriptDescriptor());
@@ -310,7 +312,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
     @NotNull
     public NameGenerator getInlineNameGenerator() {
         if (inlineNameGenerator == null) {
-            String prefix = InlineCodegenUtil.getInlineName(context, typeMapper);
+            String prefix = InlineCodegenUtil.getInlineName(context, typeMapper, fileClassesManager);
             inlineNameGenerator = new NameGenerator(prefix);
         }
         return inlineNameGenerator;

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

@@ -312,7 +312,7 @@ public class PackageCodegen {
     @Nullable
     private ClassBuilder generate(@NotNull JetFile file, @NotNull Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks) {
         boolean generatePackagePart = false;
-        Type packagePartType = PackagePartClassUtils.getPackagePartType(file);
+        Type packagePartType = state.getFileClassesManager().getFileClassType(file);
         PackageContext packagePartContext = CodegenContext.STATIC.intoPackagePart(packageFragment, packagePartType);
 
         for (JetDeclaration declaration : file.getDeclarations()) {
@@ -414,7 +414,7 @@ public class PackageCodegen {
 
     public void generateClassOrObject(@NotNull JetClassOrObject classOrObject) {
         JetFile file = classOrObject.getContainingJetFile();
-        Type packagePartType = PackagePartClassUtils.getPackagePartType(file);
+        Type packagePartType = state.getFileClassesManager().getFileClassType(file);
         CodegenContext context = CodegenContext.STATIC.intoPackagePart(packageFragment, packagePartType);
         MemberCodegen.genClassOrObject(context, classOrObject, state, null);
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java

@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.codegen.when.SwitchCodegenUtil;
 import org.jetbrains.kotlin.codegen.when.WhenByEnumsMapping;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor;
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -75,12 +75,14 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     private final BindingContext bindingContext;
     private final GenerationState.GenerateClassFilter filter;
     private final JvmRuntimeTypes runtimeTypes;
+    private final JvmFileClassesProvider fileClassesManager;
 
     public CodegenAnnotatingVisitor(@NotNull GenerationState state) {
         this.bindingTrace = state.getBindingTrace();
         this.bindingContext = state.getBindingContext();
         this.filter = state.getGenerateDeclaredClassFilter();
         this.runtimeTypes = state.getJvmRuntimeTypes();
+        this.fileClassesManager = state.getFileClassesManager();
     }
 
     @NotNull
@@ -333,7 +335,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     private void recordClosure(@NotNull ClassDescriptor classDescriptor, @NotNull String name) {
-        CodegenBinding.recordClosure(bindingTrace, classDescriptor, peekFromStack(classStack), Type.getObjectType(name));
+        CodegenBinding.recordClosure(bindingTrace, classDescriptor, peekFromStack(classStack), Type.getObjectType(name), fileClassesManager);
     }
 
     @Override
@@ -391,7 +393,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         else if (containingDeclaration instanceof PackageFragmentDescriptor) {
             JetFile containingFile = DescriptorToSourceUtils.getContainingFile(descriptor);
             assert containingFile != null : "File not found for " + descriptor;
-            return PackagePartClassUtils.getPackagePartInternalName(containingFile) + '$' + name;
+            return fileClassesManager.getFileClassInternalName(containingFile) + '$' + name;
         }
 
         return null;
@@ -572,7 +574,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
             }
         }
 
-        return PackagePartClassUtils.getPackagePartInternalName(file);
+        return fileClassesManager.getFileClassInternalName(file);
     }
 
     private static <T> T peekFromStack(@NotNull Stack<T> stack) {

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.when.WhenByEnumsMapping;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
@@ -161,7 +162,8 @@ public class CodegenBinding {
             @NotNull BindingTrace trace,
             @NotNull ClassDescriptor classDescriptor,
             @Nullable ClassDescriptor enclosing,
-            @NotNull Type asmType
+            @NotNull Type asmType,
+            @NotNull JvmFileClassesProvider fileClassesManager
     ) {
         JetElement element = (JetElement) descriptorToDeclaration(classDescriptor);
         assert element != null : "No source element for " + classDescriptor;
@@ -172,7 +174,7 @@ public class CodegenBinding {
             closure.setCaptureThis();
         }
 
-        assert PsiCodegenPredictor.checkPredictedNameFromPsi(classDescriptor, asmType);
+        assert PsiCodegenPredictor.checkPredictedNameFromPsi(classDescriptor, asmType, fileClassesManager);
         trace.record(ASM_TYPE, classDescriptor, asmType);
         trace.record(CLOSURE, classDescriptor, closure);
 
@@ -197,7 +199,12 @@ public class CodegenBinding {
     }
 
     // SCRIPT: register asmType for script, move to ScriptingUtil
-    public static void registerClassNameForScript(@NotNull BindingTrace trace, @NotNull JetScript script, @NotNull Type asmType) {
+    public static void registerClassNameForScript(
+            @NotNull BindingTrace trace,
+            @NotNull JetScript script,
+            @NotNull Type asmType,
+            @NotNull JvmFileClassesProvider fileClassesManager
+    ) {
         ScriptDescriptor descriptor = trace.getBindingContext().get(SCRIPT, script);
         if (descriptor == null) {
             throw new IllegalStateException("Script descriptor is not found for PSI: " + PsiUtilPackage.getElementTextWithContext(script));
@@ -210,7 +217,7 @@ public class CodegenBinding {
                                         toSourceElement(script));
         classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
 
-        recordClosure(trace, classDescriptor, null, asmType);
+        recordClosure(trace, classDescriptor, null, asmType, fileClassesManager);
 
         trace.record(CLASS_FOR_SCRIPT, descriptor, classDescriptor);
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.AsmUtil;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -33,10 +33,14 @@ public final class PsiCodegenPredictor {
     private PsiCodegenPredictor() {
     }
 
-    public static boolean checkPredictedNameFromPsi(@NotNull DeclarationDescriptor descriptor, @Nullable Type nameFromDescriptors) {
+    public static boolean checkPredictedNameFromPsi(
+            @NotNull DeclarationDescriptor descriptor,
+            @Nullable Type nameFromDescriptors,
+            @NotNull JvmFileClassesProvider fileClassesManager
+    ) {
         PsiElement element = descriptorToDeclaration(descriptor);
         if (element instanceof JetDeclaration) {
-            String classNameFromPsi = getPredefinedJvmInternalName((JetDeclaration) element);
+            String classNameFromPsi = getPredefinedJvmInternalName((JetDeclaration) element, fileClassesManager);
             assert classNameFromPsi == null || Type.getObjectType(classNameFromPsi).equals(nameFromDescriptors) :
                     String.format("Invalid algorithm for getting qualified name from psi! Predicted: %s, actual %s\n" +
                                   "Element: %s", classNameFromPsi, nameFromDescriptors, element.getText());
@@ -49,7 +53,10 @@ public final class PsiCodegenPredictor {
      * @return null if no prediction can be done.
      */
     @Nullable
-    public static String getPredefinedJvmInternalName(@NotNull JetDeclaration declaration) {
+    public static String getPredefinedJvmInternalName(
+            @NotNull JetDeclaration declaration,
+            @NotNull JvmFileClassesProvider fileClassesManager
+    ) {
         // TODO: Method won't work for declarations inside companion objects
         // TODO: Method won't give correct class name for traits implementations
 
@@ -57,7 +64,7 @@ public final class PsiCodegenPredictor {
 
         String parentInternalName;
         if (parentDeclaration != null) {
-            parentInternalName = getPredefinedJvmInternalName(parentDeclaration);
+            parentInternalName = getPredefinedJvmInternalName(parentDeclaration, fileClassesManager);
             if (parentInternalName == null) {
                 return null;
             }
@@ -67,7 +74,7 @@ public final class PsiCodegenPredictor {
 
             if (declaration instanceof JetNamedFunction) {
                 Name name = ((JetNamedFunction) declaration).getNameAsName();
-                return name == null ? null : PackagePartClassUtils.getPackagePartInternalName(containingFile) + "$" + name.asString();
+                return name == null ? null : fileClassesManager.getFileClassInternalName(containingFile) + "$" + name.asString();
             }
 
             parentInternalName = AsmUtil.internalNameByFqNameWithoutInnerClasses(containingFile.getPackageFqName());

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java

@@ -32,10 +32,10 @@ import org.jetbrains.kotlin.codegen.context.PackageContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinder;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -204,11 +204,20 @@ public class InlineCodegenUtil {
         return null;
     }
 
-    public static String getInlineName(@NotNull CodegenContext codegenContext, @NotNull JetTypeMapper typeMapper) {
-        return getInlineName(codegenContext, codegenContext.getContextDescriptor(), typeMapper);
+    public static String getInlineName(
+            @NotNull CodegenContext codegenContext,
+            @NotNull JetTypeMapper typeMapper,
+            @NotNull JvmFileClassesProvider fileClassesManager
+    ) {
+        return getInlineName(codegenContext, codegenContext.getContextDescriptor(), typeMapper, fileClassesManager);
     }
 
-    private static String getInlineName(@NotNull CodegenContext codegenContext, @NotNull DeclarationDescriptor currentDescriptor, @NotNull JetTypeMapper typeMapper) {
+    private static String getInlineName(
+            @NotNull CodegenContext codegenContext,
+            @NotNull DeclarationDescriptor currentDescriptor,
+            @NotNull JetTypeMapper typeMapper,
+            @NotNull JvmFileClassesProvider fileClassesManager
+    ) {
         if (currentDescriptor instanceof PackageFragmentDescriptor) {
             PsiFile file = getContainingFile(codegenContext);
 
@@ -218,7 +227,7 @@ public class InlineCodegenUtil {
                 assert codegenContext instanceof PackageContext : "Expected package context but " + codegenContext;
                 packagePartType = ((PackageContext) codegenContext).getPackagePartType();
             } else {
-                packagePartType = PackagePartClassUtils.getPackagePartType((JetFile) file);
+                packagePartType = fileClassesManager.getFileClassType((JetFile) file);
             }
 
             if (packagePartType == null) {
@@ -245,7 +254,7 @@ public class InlineCodegenUtil {
         String suffix = currentDescriptor.getName().isSpecial() ? "" : currentDescriptor.getName().asString();
 
         //noinspection ConstantConditions
-        return getInlineName(codegenContext, currentDescriptor.getContainingDeclaration(), typeMapper) + "$" + suffix;
+        return getInlineName(codegenContext, currentDescriptor.getContainingDeclaration(), typeMapper, fileClassesManager) + "$" + suffix;
     }
 
     public static boolean isInvokeOnLambda(@NotNull String owner, @NotNull String name) {

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

@@ -19,12 +19,13 @@ package org.jetbrains.kotlin.codegen.signature
 import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
 import org.jetbrains.kotlin.resolve.BindingContext
 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)
+    private val typeMapper: JetTypeMapper = JetTypeMapper(BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider)
 
     override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapSignature(function)
 }

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

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.codegen.ClassBuilderMode
 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
 
 private val EXTERNAL_SOURCES_KINDS = arrayOf(
         JvmDeclarationOriginKind.DELEGATION_TO_TRAIT_IMPL,
@@ -40,11 +41,12 @@ private val EXTERNAL_SOURCES_KINDS = arrayOf(
 class BuilderFactoryForDuplicateSignatureDiagnostics(
         builderFactory: ClassBuilderFactory,
         bindingContext: BindingContext,
-        private val diagnostics: DiagnosticSink
+        private val diagnostics: DiagnosticSink,
+        fileClassesProvider: JvmFileClassesProvider
 ) : SignatureCollectingClassBuilderFactory(builderFactory) {
 
     // Avoid errors when some classes are not loaded for some reason
-    private val typeMapper = JetTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES)
+    private val typeMapper = JetTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES, fileClassesProvider)
 
     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

@@ -27,6 +27,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.fileClasses.JvmFileClassesProvider
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.FqName
@@ -81,10 +82,15 @@ public class GenerationState jvmOverloads constructor(
         }
     }
 
+    public val fileClassesManager: CodegenFileClassesProvider =
+            CodegenFileClassesProvider.createForCodegenTask(bindingContext, files, packagesWithObsoleteParts,
+                                                           /* TODO */ multifileFacadesWithObsoleteParts = emptySet())
+
     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 = JetTypeMapperWithOutDirectory(this.bindingContext, classBuilderMode, outDirectory)
+    public val typeMapper: JetTypeMapper =
+            JetTypeMapperWithOutDirectory(this.bindingContext, classBuilderMode, fileClassesManager, outDirectory)
     public val intrinsics: IntrinsicMethods = IntrinsicMethods()
     public val samWrapperClasses: SamWrapperClasses = SamWrapperClasses(this)
     public val inlineCycleReporter: InlineCycleReporter = InlineCycleReporter(diagnostics)
@@ -108,7 +114,7 @@ public class GenerationState jvmOverloads constructor(
     init {
         val optimizationClassBuilderFactory = OptimizationClassBuilderFactory(builderFactory, disableOptimization)
         var interceptedBuilderFactory: ClassBuilderFactory = BuilderFactoryForDuplicateSignatureDiagnostics(
-                optimizationClassBuilderFactory, this.bindingContext, diagnostics)
+                optimizationClassBuilderFactory, this.bindingContext, diagnostics, fileClassesManager)
 
         interceptedBuilderFactory = BuilderFactoryForDuplicateClassNameDiagnostics(interceptedBuilderFactory, diagnostics);
 

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

@@ -30,10 +30,10 @@ import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor;
 import org.jetbrains.kotlin.codegen.context.CodegenContext;
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeDeclarationsPackage;
 import org.jetbrains.kotlin.name.ClassId;
@@ -82,10 +82,16 @@ import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 public class JetTypeMapper {
     private final BindingContext bindingContext;
     private final ClassBuilderMode classBuilderMode;
+    private final JvmFileClassesProvider fileClassesManager;
 
-    public JetTypeMapper(@NotNull BindingContext bindingContext, @NotNull ClassBuilderMode classBuilderMode) {
+    public JetTypeMapper(
+            @NotNull BindingContext bindingContext,
+            @NotNull ClassBuilderMode classBuilderMode,
+            @NotNull JvmFileClassesProvider fileClassesManager
+    ) {
         this.bindingContext = bindingContext;
         this.classBuilderMode = classBuilderMode;
+        this.fileClassesManager = fileClassesManager;
     }
 
     @NotNull
@@ -154,7 +160,7 @@ public class JetTypeMapper {
     }
 
     @NotNull
-    private static String internalNameForPackage(
+    private String internalNameForPackage(
             @NotNull PackageFragmentDescriptor packageFragment,
             @NotNull CallableMemberDescriptor descriptor,
             boolean insideModule
@@ -162,7 +168,7 @@ public class JetTypeMapper {
         ///if (insideModule) {
             JetFile file = DescriptorToSourceUtils.getContainingFile(descriptor);
             if (file != null) {
-                return PackagePartClassUtils.getPackagePartInternalName(file);
+                return fileClassesManager.getFileClassInternalName(file);
             }
 
             CallableMemberDescriptor directMember = getDirectMember(descriptor);
@@ -396,7 +402,7 @@ public class JetTypeMapper {
         }
 
         Type asmType = Type.getObjectType(computeAsmTypeImpl(klass));
-        assert PsiCodegenPredictor.checkPredictedNameFromPsi(klass, asmType);
+        assert PsiCodegenPredictor.checkPredictedNameFromPsi(klass, asmType, fileClassesManager);
         return asmType;
     }
 

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen.state;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.ClassBuilderMode;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
 import java.io.File;
@@ -32,9 +33,10 @@ public class JetTypeMapperWithOutDirectory extends JetTypeMapper {
     public JetTypeMapperWithOutDirectory(
             @NotNull BindingContext bindingContext,
             @NotNull ClassBuilderMode classBuilderMode,
+            @NotNull JvmFileClassesProvider fileClassesManager,
             @Nullable File outDirectory
     ) {
-        super(bindingContext, classBuilderMode);
+        super(bindingContext, classBuilderMode, fileClassesManager);
         this.outDirectory = outDirectory;
     }