Drop JvmFileClassesProvider and inline implementations

Both of its implementations called the same static function; inline
those and move related utilities to JvmFileClassUtil

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

@@ -1,27 +0,0 @@
-/*
- * 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.psi.KtFile
-
-class CodegenFileClassesProvider : JvmFileClassesProvider {
-    override fun getFileClassInfo(file: KtFile): JvmFileClassInfo =
-            JvmFileClassUtil.getFileClassInfoNoResolve(file)
-}

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

@@ -21,6 +21,7 @@ import kotlin.collections.SetsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.KtFile;
@@ -55,7 +56,7 @@ public class KotlinCodegenFacade {
         for (KtFile file : files) {
             if (file == null) throw new IllegalArgumentException("A null file given for compilation");
 
-            JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
+            JvmFileClassInfo fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(file);
 
             if (fileClassInfo.getWithJvmMultifileClass()) {
                 filesInMultifileClasses.putValue(fileClassInfo.getFacadeClassFqName(), file);

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

@@ -37,8 +37,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
-import org.jetbrains.kotlin.fileClasses.FileClasses;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JavaVisibilities;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
@@ -98,7 +97,6 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     public final KotlinTypeMapper typeMapper;
     public final BindingContext bindingContext;
 
-    private final JvmFileClassesProvider fileClassesProvider;
     private final MemberCodegen<?> parentCodegen;
     private final ReifiedTypeParametersUsages reifiedTypeParametersUsages = new ReifiedTypeParametersUsages();
     private final Collection<ClassDescriptor> innerClasses = new LinkedHashSet<>();
@@ -118,7 +116,6 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         this.state = state;
         this.typeMapper = state.getTypeMapper();
         this.bindingContext = state.getBindingContext();
-        this.fileClassesProvider = state.getFileClassesProvider();
         this.element = element;
         this.context = context;
         this.v = builder;
@@ -433,7 +430,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                 return implementationOwnerType;
             }
             else {
-                return FileClasses.getFileClassType(fileClassesProvider, element.getContainingKtFile());
+                return Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(element.getContainingKtFile()));
             }
         }
 
@@ -461,7 +458,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     @NotNull
     public NameGenerator getInlineNameGenerator() {
         if (inlineNameGenerator == null) {
-            String prefix = getInlineName(context, typeMapper, fileClassesProvider);
+            String prefix = getInlineName(context, typeMapper);
             inlineNameGenerator = new NameGenerator(prefix);
         }
         return inlineNameGenerator;

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

@@ -77,9 +77,6 @@ class MultifileClassCodegenImpl(
                     .getContributedDescriptors(DescriptorKindFilter.CALLABLES, MemberScope.ALL_NAME_FILTER)
                     .filterIsInstance<DeserializedCallableMemberDescriptor>()
 
-    private fun KtFile.getFileClassFqName() =
-            state.fileClassesProvider.getFileClassInfo(this).fileClassFqName
-
     private val shouldGeneratePartHierarchy =
             state.inheritMultifileParts
 
@@ -87,7 +84,7 @@ class MultifileClassCodegenImpl(
         val partInternalNamesSet = hashSetOf<String>()
         for (file in files) {
             if (file.hasDeclarationsForPartClass()) {
-                partInternalNamesSet.add(file.getFileClassFqName().toInternalName())
+                partInternalNamesSet.add(JvmFileClassUtil.getFileClassInternalName(file))
             }
         }
         compiledPackageFragment?.let {
@@ -205,7 +202,7 @@ class MultifileClassCodegenImpl(
         val packageFragment = this.packageFragment
                               ?: throw AssertionError("File part $file of $facadeFqName: no package fragment")
 
-        val partType = file.getFileClassFqName().toAsmType()
+        val partType = Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(file))
         val partContext = state.rootContext.intoMultifileClassPart(packageFragment, facadeClassType, partType, file)
 
         generateNonPartClassDeclarations(file, partContext)
@@ -372,12 +369,6 @@ class MultifileClassCodegenImpl(
         private fun KtFile.hasDeclarationsForPartClass() =
                 declarations.any { it is KtProperty || it is KtFunction }
 
-        private fun FqName.toInternalName() =
-                AsmUtil.internalNameByFqNameWithoutInnerClasses(this)
-
-        private fun FqName.toAsmType() =
-                AsmUtil.asmTypeByFqNameWithoutInnerClasses(this)
-
         private fun getCompiledPackageFragment(
                 facadeFqName: FqName, state: GenerationState
         ): IncrementalPackageFragmentProvider.IncrementalMultifileClassPackageFragment? {
@@ -393,5 +384,4 @@ class MultifileClassCodegenImpl(
             return incrementalPackageFragment?.getPackageFragmentForMultifileClass(facadeFqName)
         }
     }
-
 }

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

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
@@ -88,11 +89,8 @@ public class PackageCodegenImpl implements PackageCodegen {
     }
 
     private void generateFile(@NotNull KtFile file) {
-        JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
+        JvmFileClassInfo fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(file);
-
+        if (fileClassInfo.getWithJvmMultifileClass()) return;
-        if (fileClassInfo.getWithJvmMultifileClass()) {
-            return;
-        }
 
         Type fileClassType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(fileClassInfo.getFileClassFqName());
         PackageContext packagePartContext = state.getRootContext().intoPackagePart(packageFragment, fileClassType, file);

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

@@ -37,8 +37,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
-import org.jetbrains.kotlin.fileClasses.FileClasses;
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.sam.SamConstructorDescriptor;
 import org.jetbrains.kotlin.load.kotlin.TypeMappingConfiguration;
@@ -85,7 +84,6 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
     private final BindingContext bindingContext;
     private final GenerationState.GenerateClassFilter filter;
     private final JvmRuntimeTypes runtimeTypes;
-    private final JvmFileClassesProvider fileClassesProvider;
     private final TypeMappingConfiguration<Type> typeMappingConfiguration;
     private final SwitchCodegenProvider switchCodegenProvider;
 
@@ -94,7 +92,6 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         this.bindingContext = state.getBindingContext();
         this.filter = state.getGenerateDeclaredClassFilter();
         this.runtimeTypes = state.getJvmRuntimeTypes();
-        this.fileClassesProvider = state.getFileClassesProvider();
         this.typeMappingConfiguration = state.getTypeMapper().getTypeMappingConfiguration();
         this.switchCodegenProvider = new SwitchCodegenProvider(state);
     }
@@ -462,7 +459,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
             }
         }
 
-        return Type.getObjectType(FileClasses.getFileClassInternalName(fileClassesProvider, property.getContainingKtFile()));
+        return Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(property.getContainingKtFile()));
     }
 
     @Override
@@ -548,7 +545,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         else if (containingDeclaration instanceof PackageFragmentDescriptor) {
             KtFile containingFile = DescriptorToSourceUtils.getContainingFile(descriptor);
             assert containingFile != null : "File not found for " + descriptor;
-            return FileClasses.getFileClassInternalName(fileClassesProvider, containingFile) + '$' + name;
+            return JvmFileClassUtil.getFileClassInternalName(containingFile) + '$' + name;
         }
 
         return null;
@@ -728,7 +725,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
             }
         }
 
-        return FileClasses.getFacadeClassInternalName(fileClassesProvider, file);
+        return JvmFileClassUtil.getFacadeClassInternalName(file);
     }
 
     private static <T> T peekFromStack(@NotNull Stack<T> stack) {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt

@@ -33,8 +33,7 @@ import org.jetbrains.kotlin.codegen.optimization.common.intConstant
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.getFileClassType
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryPackageSourceElement
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
@@ -61,7 +60,6 @@ import org.jetbrains.org.objectweb.asm.util.TraceMethodVisitor
 import java.io.PrintWriter
 import java.io.StringWriter
 
-
 const val GENERATE_SMAP = true
 const val API = Opcodes.ASM5
 const val NUMBERED_FUNCTION_PREFIX = "kotlin/jvm/functions/Function"
@@ -158,31 +156,25 @@ internal fun findVirtualFileImprecise(state: GenerationState, internalClassName:
     return findVirtualFile(state, ClassId(packageFqName, Name.identifier(classNameWithDollars)))
 }
 
-internal fun getInlineName(
+internal fun getInlineName(codegenContext: CodegenContext<*>, typeMapper: KotlinTypeMapper): String =
-        codegenContext: CodegenContext<*>,
+        getInlineName(codegenContext, codegenContext.contextDescriptor, typeMapper)
-        typeMapper: KotlinTypeMapper,
-        fileClassesManager: JvmFileClassesProvider
-): String {
-    return getInlineName(codegenContext, codegenContext.contextDescriptor, typeMapper, fileClassesManager)
-}
 
 private fun getInlineName(
         codegenContext: CodegenContext<*>,
         currentDescriptor: DeclarationDescriptor,
-        typeMapper: KotlinTypeMapper,
+        typeMapper: KotlinTypeMapper
-        fileClassesProvider: JvmFileClassesProvider
 ): String {
     when (currentDescriptor) {
         is PackageFragmentDescriptor -> {
             val file = DescriptorToSourceUtils.getContainingFile(codegenContext.contextDescriptor)
 
-            val implementationOwnerType: Type? =
+            val implementationOwnerInternalName: String? =
                     if (file == null) {
-                        CodegenContextUtil.getImplementationOwnerClassType(codegenContext)
+                        CodegenContextUtil.getImplementationOwnerClassType(codegenContext)?.internalName
                     }
-                    else fileClassesProvider.getFileClassType(file)
+                    else JvmFileClassUtil.getFileClassInternalName(file)
 
-            if (implementationOwnerType == null) {
+            if (implementationOwnerInternalName == null) {
                 val contextDescriptor = codegenContext.contextDescriptor
                 throw RuntimeException(
                         "Couldn't find declaration for " +
@@ -191,7 +183,7 @@ private fun getInlineName(
                 )
             }
 
-            return implementationOwnerType.internalName
+            return implementationOwnerInternalName
         }
         is ClassifierDescriptor -> {
             return typeMapper.mapType(currentDescriptor).internalName
@@ -207,8 +199,7 @@ private fun getInlineName(
     //TODO: add suffix for special case
     val suffix = if (currentDescriptor.name.isSpecial) "" else currentDescriptor.name.asString()
 
-
+    return getInlineName(codegenContext, currentDescriptor.containingDeclaration!!, typeMapper) + "$" + suffix
-    return getInlineName(codegenContext, currentDescriptor.containingDeclaration!!, typeMapper, fileClassesProvider) + "$" + suffix
 }
 
 internal fun isInvokeOnLambda(owner: String, name: String): Boolean {

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

@@ -20,14 +20,13 @@ import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.state.IncompatibleClassTracker
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.KotlinToJvmSignatureMapper
 
 class KotlinToJvmSignatureMapperImpl : KotlinToJvmSignatureMapper {
     // We use empty BindingContext, because it is only used by KotlinTypeMapper for purposes irrelevant to the needs of this class
-    private val typeMapper = KotlinTypeMapper(BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider,
+    private val typeMapper = KotlinTypeMapper(BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES,
                                               IncompatibleClassTracker.DoNothing, JvmAbi.DEFAULT_MODULE_NAME, false, false)
 
     override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapAsmMethod(function)

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

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider
 import org.jetbrains.kotlin.load.java.descriptors.getParentJavaStaticClassScope
 import org.jetbrains.kotlin.load.java.sam.SamAdapterDescriptor
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -57,14 +56,13 @@ class BuilderFactoryForDuplicateSignatureDiagnostics(
         builderFactory: ClassBuilderFactory,
         bindingContext: BindingContext,
         private val diagnostics: DiagnosticSink,
-        fileClassesProvider: JvmFileClassesProvider,
         moduleName: String,
         shouldGenerate: (JvmDeclarationOrigin) -> Boolean
 ) : SignatureCollectingClassBuilderFactory(builderFactory, shouldGenerate) {
 
     // Avoid errors when some classes are not loaded for some reason
     private val typeMapper = KotlinTypeMapper(
-            bindingContext, ClassBuilderMode.LIGHT_CLASSES, fileClassesProvider, IncompatibleClassTracker.DoNothing, moduleName, false, false
+            bindingContext, ClassBuilderMode.LIGHT_CLASSES, IncompatibleClassTracker.DoNothing, moduleName, false, false
     )
     private val reportDiagnosticsTasks = ArrayList<() -> Unit>()
 

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

@@ -87,7 +87,6 @@ class GenerationState @JvmOverloads constructor(
         }
     }
 
-    val fileClassesProvider: CodegenFileClassesProvider = CodegenFileClassesProvider()
     val inlineCache: InlineCache = InlineCache()
 
     val incrementalCacheForThisTarget: IncrementalCache?
@@ -138,7 +137,7 @@ class GenerationState @JvmOverloads constructor(
                                                             filter = if (wantsDiagnostics) BindingTraceFilter.ACCEPT_ALL else BindingTraceFilter.NO_DIAGNOSTICS)
     val bindingContext: BindingContext = bindingTrace.bindingContext
     val typeMapper: KotlinTypeMapper = KotlinTypeMapper(
-            this.bindingContext, classBuilderMode, fileClassesProvider, IncompatibleClassTrackerImpl(extraJvmDiagnosticsTrace),
+            this.bindingContext, classBuilderMode, IncompatibleClassTrackerImpl(extraJvmDiagnosticsTrace),
             this.moduleName, isJvm8Target, isJvm8TargetWithDefaults
     )
     val intrinsics: IntrinsicMethods = IntrinsicMethods(target)
@@ -184,8 +183,7 @@ class GenerationState @JvmOverloads constructor(
                 .wrapWith(
                     { OptimizationClassBuilderFactory(it, configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false)) },
                     { BuilderFactoryForDuplicateSignatureDiagnostics(
-                            it, this.bindingContext, diagnostics,
+                            it, this.bindingContext, diagnostics, this.moduleName,
-                            fileClassesProvider, this.moduleName,
                             shouldGenerate = { !shouldOnlyCollectSignatures(it) }
                     ).apply { duplicateSignatureFactory = this } },
                     { BuilderFactoryForDuplicateClassNameDiagnostics(it, diagnostics) },

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

@@ -38,10 +38,8 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableAccessorDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor;
-import org.jetbrains.kotlin.fileClasses.FileClasses;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature;
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.SpecialSignatureInfo;
 import org.jetbrains.kotlin.load.java.JvmAbi;
@@ -94,7 +92,6 @@ import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 public class KotlinTypeMapper {
     private final BindingContext bindingContext;
     private final ClassBuilderMode classBuilderMode;
-    private final JvmFileClassesProvider fileClassesProvider;
     private final IncompatibleClassTracker incompatibleClassTracker;
     private final String moduleName;
     private final boolean isJvm8Target;
@@ -137,7 +134,6 @@ public class KotlinTypeMapper {
     public KotlinTypeMapper(
             @NotNull BindingContext bindingContext,
             @NotNull ClassBuilderMode classBuilderMode,
-            @NotNull JvmFileClassesProvider fileClassesProvider,
             @NotNull IncompatibleClassTracker incompatibleClassTracker,
             @NotNull String moduleName,
             boolean isJvm8Target,
@@ -145,7 +141,6 @@ public class KotlinTypeMapper {
     ) {
         this.bindingContext = bindingContext;
         this.classBuilderMode = classBuilderMode;
-        this.fileClassesProvider = fileClassesProvider;
         this.incompatibleClassTracker = incompatibleClassTracker;
         this.moduleName = moduleName;
         this.isJvm8Target = isJvm8Target;
@@ -208,10 +203,10 @@ public class KotlinTypeMapper {
                 Visibilities.isPrivate(visibility) ||
                 isAccessor/*Cause of KT-9603*/
             ) {
-                return FileClasses.getFileClassInternalName(fileClassesProvider, file);
+                return JvmFileClassUtil.getFileClassInternalName(file);
             }
             else {
-                return FileClasses.getFacadeClassInternalName(fileClassesProvider, file);
+                return JvmFileClassUtil.getFacadeClassInternalName(file);
             }
         }
 

compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberDescriptor
 
 object JvmFileClassUtil {
@@ -40,6 +41,14 @@ object JvmFileClassUtil {
         return (descriptor.containingDeclaration as PackageFragmentDescriptor).fqName.child(implClassName)
     }
 
+    @JvmStatic
+    fun getFileClassInternalName(file: KtFile): String =
+            getFileClassInfoNoResolve(file).fileClassFqName.internalNameWithoutInnerClasses
+
+    @JvmStatic
+    fun getFacadeClassInternalName(file: KtFile): String =
+            getFileClassInfoNoResolve(file).facadeClassFqName.internalNameWithoutInnerClasses
+
     private fun manglePartName(facadeName: String, fileName: String): String =
             "$facadeName$MULTIFILE_PART_NAME_DELIMITER${PackagePartClassUtils.getFilePartShortName(fileName)}"
 
@@ -100,3 +109,6 @@ fun KtDeclaration.isInsideJvmMultifileClassFile() = JvmFileClassUtil.findAnnotat
         containingKtFile,
         JvmFileClassUtil.JVM_MULTIFILE_CLASS_SHORT
 ) != null
+
+val FqName.internalNameWithoutInnerClasses: String
+    get() = JvmClassName.byFqNameWithoutInnerClasses(this).internalName

compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassesProvider.kt

@@ -1,42 +0,0 @@
-/*
- * 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.
- */
-
-@file:JvmName("FileClasses")
-package org.jetbrains.kotlin.fileClasses
-
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.jvm.JvmClassName
-import org.jetbrains.org.objectweb.asm.Type
-
-interface JvmFileClassesProvider {
-    fun getFileClassInfo(file: KtFile): JvmFileClassInfo
-}
-
-val FqName.internalNameWithoutInnerClasses: String
-    get() = JvmClassName.byFqNameWithoutInnerClasses(this).internalName
-
-fun JvmFileClassesProvider.getFileClassFqName(file: KtFile): FqName =
-        getFileClassInfo(file).fileClassFqName
-
-fun JvmFileClassesProvider.getFileClassInternalName(file: KtFile): String =
-        getFileClassFqName(file).internalNameWithoutInnerClasses
-
-fun JvmFileClassesProvider.getFileClassType(file: KtFile): Type =
-        Type.getObjectType(getFileClassFqName(file).internalNameWithoutInnerClasses)
-
-fun JvmFileClassesProvider.getFacadeClassInternalName(file: KtFile): String =
-        getFileClassInfo(file).facadeClassFqName.internalNameWithoutInnerClasses

compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/NoResolveFileClassesProvider.kt

@@ -1,24 +0,0 @@
-/*
- * 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.fileClasses
-
-import org.jetbrains.kotlin.psi.KtFile
-
-object NoResolveFileClassesProvider : JvmFileClassesProvider {
-    override fun getFileClassInfo(file: KtFile): JvmFileClassInfo =
-            JvmFileClassUtil.getFileClassInfoNoResolve(file)
-}

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmOverloadFilter.kt

@@ -19,8 +19,7 @@ package org.jetbrains.kotlin.resolve.jvm
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorNonRoot
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.getFileClassFqName
 import org.jetbrains.kotlin.load.java.descriptors.getImplClassNameForDeserialized
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -36,7 +35,7 @@ object JvmOverloadFilter : OverloadFilter {
         for (overload in overloads) {
             val file = DescriptorToSourceUtils.getContainingFile(overload) ?: continue
             result.add(overload)
-            sourceClassesFQNs.add(NoResolveFileClassesProvider.getFileClassFqName(file))
+            sourceClassesFQNs.add(JvmFileClassUtil.getFileClassInfoNoResolve(file).fileClassFqName)
         }
 
         for (overload in overloads) {

compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/LightClassDataProvider.kt

@@ -27,14 +27,14 @@ import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.getFileClassType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtPsiUtil
 import org.jetbrains.kotlin.psi.KtScript
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
+import org.jetbrains.org.objectweb.asm.Type
 
 class LightClassDataProviderForClassOrObject(
         private val classOrObject: KtClassOrObject
@@ -48,7 +48,7 @@ class LightClassDataProviderForClassOrObject(
             buildLightClass(packageFqName, listOf(file), ClassFilterForClassOrObject(classOrObject), constructionContext) {
                 state, files ->
                 val packageCodegen = state.factory.forPackage(packageFqName, files)
-                val packagePartType = state.fileClassesProvider.getFileClassType(file)
+                val packagePartType = Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(file))
                 val context = state.rootContext.intoPackagePart(packageCodegen.packageFragment, packagePartType, file)
                 packageCodegen.generateClassOrObject(getOutermostClassOrObject(classOrObject), context)
                 state.factory.done()
@@ -79,7 +79,7 @@ sealed class LightClassDataProviderForFileFacade constructor(
             buildLightClass(facadeFqName.parent(), files, ClassFilterForFacade, constructionContext) generate@ {
                 state, files ->
                 val representativeFile = files.first()
-                val fileClassInfo = NoResolveFileClassesProvider.getFileClassInfo(representativeFile)
+                val fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(representativeFile)
                 if (!fileClassInfo.withJvmMultifileClass) {
                     val codegen = state.factory.forPackage(representativeFile.packageFqName, files)
                     codegen.generate(CompilationErrorHandler.THROW_EXCEPTION)

compiler/light-classes/src/org/jetbrains/kotlin/asJava/duplicateJvmSignatureUtil.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory.cast
 import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
@@ -37,7 +37,7 @@ fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostic
     fun getDiagnosticsForFileFacade(file: KtFile): Diagnostics? {
         val project = file.project
         val cache = KtLightClassForFacade.FacadeStubCache.getInstance(project)
-        val facadeFqName = NoResolveFileClassesProvider.getFileClassInfo(file).facadeClassFqName
+        val facadeFqName = JvmFileClassUtil.getFileClassInfoNoResolve(file).facadeClassFqName
         return cache[facadeFqName, moduleScope].value?.extraDiagnostics
     }
 

idea/src/org/jetbrains/kotlin/idea/debugger/DebuggerClassNameProvider.kt

@@ -25,8 +25,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import com.sun.jdi.AbsentInformationException
 import com.sun.jdi.ReferenceType
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding.asmTypeForAnonymousClass
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.getFileClassInternalName
 import org.jetbrains.kotlin.idea.debugger.breakpoints.getLambdasAtLineIfAny
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinDebuggerCaches
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinDebuggerCaches.Companion.getOrComputeClassNames
@@ -115,7 +114,7 @@ class DebuggerClassNameProvider(
 
         return when (element) {
             is KtFile -> {
-                val fileClassName = runReadAction { NoResolveFileClassesProvider.getFileClassInternalName(element) }.toJdiName()
+                val fileClassName = runReadAction { JvmFileClassUtil.getFileClassInternalName(element) }.toJdiName()
                 ComputedClassNames.Cached(fileClassName)
             }
             is KtClassOrObject -> {

idea/src/org/jetbrains/kotlin/idea/debugger/KotlinPositionManager.kt

@@ -36,7 +36,6 @@ import com.sun.jdi.ReferenceType
 import com.sun.jdi.request.ClassPrepareRequest
 import org.jetbrains.kotlin.codegen.inline.KOTLIN_STRATA_NAME
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.internalNameWithoutInnerClasses
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.debugger.breakpoints.getLambdasAtLineIfAny
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinCodeFragmentFactory
@@ -234,8 +233,7 @@ class KotlinPositionManager(private val myDebugProcess: DebugProcess) : MultiReq
         if (psiFile is ClsFileImpl) {
             val decompiledPsiFile = psiFile.readAction { it.decompiledPsiFile }
             if (decompiledPsiFile is KtClsFile && sourcePosition.line == -1) {
-                val className =
+                val className = JvmFileClassUtil.getFileClassInternalName(decompiledPsiFile)
-                        JvmFileClassUtil.getFileClassInfoNoResolve(decompiledPsiFile).fileClassFqName.internalNameWithoutInnerClasses
                 return myDebugProcess.virtualMachineProxy.classesByName(className)
             }
         }

idea/tests/org/jetbrains/kotlin/idea/filters/AbstractKotlinExceptionFilterTest.kt

@@ -26,8 +26,7 @@ import com.intellij.openapi.util.io.FileUtilRt
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.PsiTestUtil
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.getFileClassFqName
 import org.jetbrains.kotlin.idea.refactoring.toVirtualFile
 import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
@@ -90,7 +89,7 @@ abstract class AbstractKotlinExceptionFilterTest : KotlinCodeInsightTestCase() {
         }
 
         val stackTraceElement = try {
-            val className = NoResolveFileClassesProvider.getFileClassFqName(file as KtFile)
+            val className = JvmFileClassUtil.getFileClassInfoNoResolve(file as KtFile).fileClassFqName
             val clazz = classLoader.loadClass(className.asString())
             clazz.getMethod("box")?.invoke(null)
             throw AssertionError("class ${className.asString()} should have box() method and throw exception")

plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.reportFromPlugin
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -176,7 +175,6 @@ class ParcelableDeclarationChecker : SimpleDeclarationChecker {
         val typeMapper = KotlinTypeMapper(
                 bindingContext,
                 ClassBuilderMode.full(false),
-                NoResolveFileClassesProvider,
                 IncompatibleClassTracker.DoNothing,
                 descriptor.module.name.asString(),
                 /* isJvm8Target */ false,

plugins/uast-kotlin-idea/src/IdeaKotlinUastBindingContextProviderService.kt

@@ -19,7 +19,6 @@ package org.jetbrains.uast.kotlin.internal
 import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.state.IncompatibleClassTracker
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtElement
@@ -30,8 +29,7 @@ class IdeaKotlinUastBindingContextProviderService : KotlinUastBindingContextProv
     override fun getBindingContext(element: KtElement) = element.analyze(BodyResolveMode.PARTIAL)
 
     override fun getTypeMapper(element: KtElement): KotlinTypeMapper? {
-        return KotlinTypeMapper(getBindingContext(element),
+        return KotlinTypeMapper(getBindingContext(element), ClassBuilderMode.LIGHT_CLASSES,
-                                ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider,
                                 IncompatibleClassTracker.DoNothing, JvmAbi.DEFAULT_MODULE_NAME, false, false)
     }
 }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastBindingContextProviderService.kt

@@ -6,7 +6,6 @@ import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.state.IncompatibleClassTracker
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
@@ -40,7 +39,7 @@ class UastAnalysisHandlerExtension : AnalysisHandlerExtension {
         if (typeMapper != null) return typeMapper
         val bindingContext = context ?: return null
 
-        val typeMapper = KotlinTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES, NoResolveFileClassesProvider,
+        val typeMapper = KotlinTypeMapper(bindingContext, ClassBuilderMode.LIGHT_CLASSES,
                                           IncompatibleClassTracker.DoNothing, JvmAbi.DEFAULT_MODULE_NAME, false, false)
         this.typeMapper = typeMapper
         return typeMapper