Get rid of split packages in descriptors, descriptors.jvm, deserialization

Also move some other files to related packages and reformat moved files
2018-07-03 14:26:01 +02:00
parent 4b1ce15619
commit 959c2f4843
82 changed files with 662 additions and 753 deletions
@@ -1,44 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.builtins
-
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.resolve.scopes.GivenFunctionsMemberScope
-import org.jetbrains.kotlin.storage.StorageManager
-
-class CloneableClassScope(
-        storageManager: StorageManager,
-        containingClass: ClassDescriptor
-) : GivenFunctionsMemberScope(storageManager, containingClass) {
-    override fun computeDeclaredFunctions(): List<FunctionDescriptor> = listOf(
-            SimpleFunctionDescriptorImpl.create(containingClass, Annotations.EMPTY, CLONE_NAME, DECLARATION, SourceElement.NO_SOURCE).apply {
-                initialize(
-                        null, containingClass.thisAsReceiverParameter, emptyList(), emptyList(), containingClass.builtIns.anyType,
-                        Modality.OPEN, Visibilities.PROTECTED
-                )
-            }
-    )
-
-    companion object {
-        internal val CLONE_NAME = Name.identifier("clone")
-    }
-}
@@ -1,65 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.builtins
-
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.deserialization.ClassDescriptorFactory
-import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.storage.getValue
-
-class JvmBuiltInClassDescriptorFactory(
-        storageManager: StorageManager,
-        private val moduleDescriptor: ModuleDescriptor,
-        private val computeContainingDeclaration: (ModuleDescriptor) -> DeclarationDescriptor = { module ->
-            module.getPackage(KOTLIN_FQ_NAME).fragments.filterIsInstance<BuiltInsPackageFragment>().first()
-        }
-) : ClassDescriptorFactory {
-    private val cloneable by storageManager.createLazyValue {
-        ClassDescriptorImpl(
-                computeContainingDeclaration(moduleDescriptor),
-                CLONEABLE_NAME, Modality.ABSTRACT, ClassKind.INTERFACE, listOf(moduleDescriptor.builtIns.anyType),
-                SourceElement.NO_SOURCE, /* isExternal = */ false, storageManager
-        ).apply {
-            initialize(CloneableClassScope(storageManager, this), emptySet(), null)
-        }
-    }
-
-    override fun shouldCreateClass(packageFqName: FqName, name: Name): Boolean =
-            name == CLONEABLE_NAME && packageFqName == KOTLIN_FQ_NAME
-
-    override fun createClass(classId: ClassId): ClassDescriptor? =
-            when (classId) {
-                CLONEABLE_CLASS_ID -> cloneable
-                else -> null
-            }
-
-    override fun getAllContributedClassesIfPossible(packageFqName: FqName): Collection<ClassDescriptor> =
-            when (packageFqName) {
-                KOTLIN_FQ_NAME -> setOf(cloneable)
-                else -> emptySet()
-            }
-
-    companion object {
-        private val KOTLIN_FQ_NAME = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME
-        private val CLONEABLE_NAME = KotlinBuiltIns.FQ_NAMES.cloneable.shortName()
-        val CLONEABLE_CLASS_ID = ClassId.topLevel(KotlinBuiltIns.FQ_NAMES.cloneable.toSafe())
-    }
-}
@@ -1,65 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.builtins
-
-import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.NotFoundClasses
-import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider
-import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentDeclarationFilter
-import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.serialization.deserialization.*
-import org.jetbrains.kotlin.storage.StorageManager
-
-class JvmBuiltInsPackageFragmentProvider(
-        storageManager: StorageManager,
-        finder: KotlinClassFinder,
-        moduleDescriptor: ModuleDescriptor,
-        notFoundClasses: NotFoundClasses,
-        additionalClassPartsProvider: AdditionalClassPartsProvider,
-        platformDependentDeclarationFilter: PlatformDependentDeclarationFilter
-) : AbstractDeserializedPackageFragmentProvider(storageManager, finder, moduleDescriptor) {
-    init {
-        components = DeserializationComponents(
-                storageManager,
-                moduleDescriptor,
-                DeserializationConfiguration.Default, // TODO
-                DeserializedClassDataFinder(this),
-                AnnotationAndConstantLoaderImpl(moduleDescriptor, notFoundClasses, BuiltInSerializerProtocol),
-                this,
-                LocalClassifierTypeSettings.Default,
-                ErrorReporter.DO_NOTHING,
-                LookupTracker.DO_NOTHING,
-                FlexibleTypeDeserializer.ThrowException,
-                listOf(
-                        BuiltInFictitiousFunctionClassFactory(storageManager, moduleDescriptor),
-                        JvmBuiltInClassDescriptorFactory(storageManager, moduleDescriptor)
-                ),
-                notFoundClasses,
-                ContractDeserializer.DEFAULT,
-                additionalClassPartsProvider, platformDependentDeclarationFilter,
-                BuiltInSerializerProtocol.extensionRegistry
-        )
-    }
-
-    override fun findPackage(fqName: FqName): DeserializedPackageFragment? =
-            finder.findBuiltInsData(fqName)?.let { inputStream ->
-                BuiltInsPackageFragmentImpl(fqName, storageManager, moduleDescriptor, inputStream)
-            }
-}
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.builtins.jvm
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.scopes.GivenFunctionsMemberScope
+import org.jetbrains.kotlin.storage.StorageManager
+
+class CloneableClassScope(
+    storageManager: StorageManager,
+    containingClass: ClassDescriptor
+) : GivenFunctionsMemberScope(storageManager, containingClass) {
+    override fun computeDeclaredFunctions(): List<FunctionDescriptor> = listOf(
+        SimpleFunctionDescriptorImpl.create(containingClass, Annotations.EMPTY, CLONE_NAME, DECLARATION, SourceElement.NO_SOURCE).apply {
+            initialize(
+                null, containingClass.thisAsReceiverParameter, emptyList(), emptyList(), containingClass.builtIns.anyType,
+                Modality.OPEN, Visibilities.PROTECTED
+            )
+        }
+    )
+
+    companion object {
+        internal val CLONE_NAME = Name.identifier("clone")
+    }
+}
@@ -3,11 +3,12 @@
 * that can be found in the license/LICENSE.txt file.
 */

-package org.jetbrains.kotlin.platform
+package org.jetbrains.kotlin.builtins.jvm

 import org.jetbrains.kotlin.builtins.CompanionObjectMapping
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns.FQ_NAMES
+import org.jetbrains.kotlin.builtins.PlatformToKotlinClassMap
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.name.*
@@ -29,9 +30,9 @@ object JavaToKotlinClassMap : PlatformToKotlinClassMap {

    // describes mapping for a java class that has separate readOnly and mutable equivalents in Kotlin
    data class PlatformMutabilityMapping(
-            val javaClass: ClassId,
-            val kotlinReadOnly: ClassId,
-            val kotlinMutable: ClassId
+        val javaClass: ClassId,
+        val kotlinReadOnly: ClassId,
+        val kotlinMutable: ClassId
    )

    private inline fun <reified T> mutabilityMapping(kotlinReadOnly: ClassId, kotlinMutable: FqName): PlatformMutabilityMapping {
@@ -40,16 +41,16 @@ object JavaToKotlinClassMap : PlatformToKotlinClassMap {
    }

    val mutabilityMappings = listOf(
-            mutabilityMapping<Iterable<*>>(ClassId.topLevel(FQ_NAMES.iterable), FQ_NAMES.mutableIterable),
-            mutabilityMapping<Iterator<*>>(ClassId.topLevel(FQ_NAMES.iterator), FQ_NAMES.mutableIterator),
-            mutabilityMapping<Collection<*>>(ClassId.topLevel(FQ_NAMES.collection), FQ_NAMES.mutableCollection),
-            mutabilityMapping<List<*>>(ClassId.topLevel(FQ_NAMES.list), FQ_NAMES.mutableList),
-            mutabilityMapping<Set<*>>(ClassId.topLevel(FQ_NAMES.set), FQ_NAMES.mutableSet),
-            mutabilityMapping<ListIterator<*>>(ClassId.topLevel(FQ_NAMES.listIterator), FQ_NAMES.mutableListIterator),
-            mutabilityMapping<Map<*, *>>(ClassId.topLevel(FQ_NAMES.map), FQ_NAMES.mutableMap),
-            mutabilityMapping<Map.Entry<*, *>>(
-                    ClassId.topLevel(FQ_NAMES.map).createNestedClassId(FQ_NAMES.mapEntry.shortName()), FQ_NAMES.mutableMapEntry
-            )
+        mutabilityMapping<Iterable<*>>(ClassId.topLevel(FQ_NAMES.iterable), FQ_NAMES.mutableIterable),
+        mutabilityMapping<Iterator<*>>(ClassId.topLevel(FQ_NAMES.iterator), FQ_NAMES.mutableIterator),
+        mutabilityMapping<Collection<*>>(ClassId.topLevel(FQ_NAMES.collection), FQ_NAMES.mutableCollection),
+        mutabilityMapping<List<*>>(ClassId.topLevel(FQ_NAMES.list), FQ_NAMES.mutableList),
+        mutabilityMapping<Set<*>>(ClassId.topLevel(FQ_NAMES.set), FQ_NAMES.mutableSet),
+        mutabilityMapping<ListIterator<*>>(ClassId.topLevel(FQ_NAMES.listIterator), FQ_NAMES.mutableListIterator),
+        mutabilityMapping<Map<*, *>>(ClassId.topLevel(FQ_NAMES.map), FQ_NAMES.mutableMap),
+        mutabilityMapping<Map.Entry<*, *>>(
+            ClassId.topLevel(FQ_NAMES.map).createNestedClassId(FQ_NAMES.mapEntry.shortName()), FQ_NAMES.mutableMapEntry
+        )
    )

    init {
@@ -68,13 +69,17 @@ object JavaToKotlinClassMap : PlatformToKotlinClassMap {
        }

        for (jvmType in JvmPrimitiveType.values()) {
-            add(ClassId.topLevel(jvmType.wrapperFqName),
-                ClassId.topLevel(KotlinBuiltIns.getPrimitiveFqName(jvmType.primitiveType)))
+            add(
+                ClassId.topLevel(jvmType.wrapperFqName),
+                ClassId.topLevel(KotlinBuiltIns.getPrimitiveFqName(jvmType.primitiveType))
+            )
        }

        for (classId in CompanionObjectMapping.allClassesWithIntrinsicCompanions()) {
-            add(ClassId.topLevel(FqName("kotlin.jvm.internal." + classId.shortClassName.asString() + "CompanionObject")),
-                classId.createNestedClassId(SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT))
+            add(
+                ClassId.topLevel(FqName("kotlin.jvm.internal." + classId.shortClassName.asString() + "CompanionObject")),
+                classId.createNestedClassId(SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT)
+            )
        }

        // TODO: support also functions with >= 23 parameters
@@ -208,11 +213,12 @@ object JavaToKotlinClassMap : PlatformToKotlinClassMap {
    }

    private fun convertToOppositeMutability(
-            descriptor: ClassDescriptor,
-            map: Map<FqNameUnsafe, FqName>,
-            mutabilityKindName: String
+        descriptor: ClassDescriptor,
+        map: Map<FqNameUnsafe, FqName>,
+        mutabilityKindName: String
    ): ClassDescriptor {
-        val oppositeClassFqName = map[DescriptorUtils.getFqName(descriptor)] ?: throw IllegalArgumentException("Given class $descriptor is not a $mutabilityKindName collection")
+        val oppositeClassFqName = map[DescriptorUtils.getFqName(descriptor)]
+                ?: throw IllegalArgumentException("Given class $descriptor is not a $mutabilityKindName collection")
        return descriptor.builtIns.getBuiltInClassByFqName(oppositeClassFqName)
    }
 }
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.builtins.jvm
+
+import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.deserialization.ClassDescriptorFactory
+import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.storage.getValue
+
+class JvmBuiltInClassDescriptorFactory(
+    storageManager: StorageManager,
+    private val moduleDescriptor: ModuleDescriptor,
+    private val computeContainingDeclaration: (ModuleDescriptor) -> DeclarationDescriptor = { module ->
+        module.getPackage(KOTLIN_FQ_NAME).fragments.filterIsInstance<BuiltInsPackageFragment>().first()
+    }
+) : ClassDescriptorFactory {
+    private val cloneable by storageManager.createLazyValue {
+        ClassDescriptorImpl(
+            computeContainingDeclaration(moduleDescriptor),
+            CLONEABLE_NAME, Modality.ABSTRACT, ClassKind.INTERFACE, listOf(moduleDescriptor.builtIns.anyType),
+            SourceElement.NO_SOURCE, false, storageManager
+        ).apply {
+            initialize(CloneableClassScope(storageManager, this), emptySet(), null)
+        }
+    }
+
+    override fun shouldCreateClass(packageFqName: FqName, name: Name): Boolean =
+        name == CLONEABLE_NAME && packageFqName == KOTLIN_FQ_NAME
+
+    override fun createClass(classId: ClassId): ClassDescriptor? =
+        when (classId) {
+            CLONEABLE_CLASS_ID -> cloneable
+            else -> null
+        }
+
+    override fun getAllContributedClassesIfPossible(packageFqName: FqName): Collection<ClassDescriptor> =
+        when (packageFqName) {
+            KOTLIN_FQ_NAME -> setOf(cloneable)
+            else -> emptySet()
+        }
+
+    companion object {
+        private val KOTLIN_FQ_NAME = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME
+        private val CLONEABLE_NAME = KotlinBuiltIns.FQ_NAMES.cloneable.shortName()
+        val CLONEABLE_CLASS_ID = ClassId.topLevel(KotlinBuiltIns.FQ_NAMES.cloneable.toSafe())
+    }
+}
@@ -1,34 +1,21 @@
 /*
- * 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.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
 */

-package org.jetbrains.kotlin.platform
+package org.jetbrains.kotlin.builtins.jvm

-import org.jetbrains.kotlin.builtins.JvmBuiltInClassDescriptorFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider
 import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentDeclarationFilter
-import org.jetbrains.kotlin.load.kotlin.JvmBuiltInsSettings
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.getValue
 import org.jetbrains.kotlin.utils.sure

 class JvmBuiltIns @JvmOverloads constructor(
-        storageManager: StorageManager,
-        loadBuiltInsFromCurrentClassLoader: Boolean = true
+    storageManager: StorageManager,
+    loadBuiltInsFromCurrentClassLoader: Boolean = true
 ) : KotlinBuiltIns(storageManager) {
    // Module containing JDK classes or having them among dependencies
    private var ownerModuleDescriptor: ModuleDescriptor? = null
@@ -42,12 +29,12 @@ class JvmBuiltIns @JvmOverloads constructor(

    val settings: JvmBuiltInsSettings by storageManager.createLazyValue {
        JvmBuiltInsSettings(
-                builtInsModule, storageManager,
-                { ownerModuleDescriptor.sure { "JvmBuiltins has not been initialized properly" } },
-                {
-                    ownerModuleDescriptor.sure { "JvmBuiltins has not been initialized properly" }
-                    isAdditionalBuiltInsFeatureSupported
-                }
+            builtInsModule, storageManager,
+            { ownerModuleDescriptor.sure { "JvmBuiltins has not been initialized properly" } },
+            {
+                ownerModuleDescriptor.sure { "JvmBuiltins has not been initialized properly" }
+                isAdditionalBuiltInsFeatureSupported
+            }
        )
    }

@@ -62,5 +49,5 @@ class JvmBuiltIns @JvmOverloads constructor(
    override fun getAdditionalClassPartsProvider(): AdditionalClassPartsProvider = settings

    override fun getClassDescriptorFactories() =
-            super.getClassDescriptorFactories() + JvmBuiltInClassDescriptorFactory(storageManager, builtInsModule)
+        super.getClassDescriptorFactories() + JvmBuiltInClassDescriptorFactory(storageManager, builtInsModule)
 }
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.builtins.jvm
+
+import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.NotFoundClasses
+import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider
+import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentDeclarationFilter
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.serialization.deserialization.*
+import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
+import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInsPackageFragmentImpl
+import org.jetbrains.kotlin.storage.StorageManager
+
+class JvmBuiltInsPackageFragmentProvider(
+    storageManager: StorageManager,
+    finder: KotlinClassFinder,
+    moduleDescriptor: ModuleDescriptor,
+    notFoundClasses: NotFoundClasses,
+    additionalClassPartsProvider: AdditionalClassPartsProvider,
+    platformDependentDeclarationFilter: PlatformDependentDeclarationFilter
+) : AbstractDeserializedPackageFragmentProvider(storageManager, finder, moduleDescriptor) {
+    init {
+        components = DeserializationComponents(
+            storageManager,
+            moduleDescriptor,
+            DeserializationConfiguration.Default, // TODO
+            DeserializedClassDataFinder(this),
+            AnnotationAndConstantLoaderImpl(moduleDescriptor, notFoundClasses, BuiltInSerializerProtocol),
+            this,
+            LocalClassifierTypeSettings.Default,
+            ErrorReporter.DO_NOTHING,
+            LookupTracker.DO_NOTHING,
+            FlexibleTypeDeserializer.ThrowException,
+            listOf(
+                BuiltInFictitiousFunctionClassFactory(storageManager, moduleDescriptor),
+                JvmBuiltInClassDescriptorFactory(storageManager, moduleDescriptor)
+            ),
+            notFoundClasses,
+            ContractDeserializer.DEFAULT,
+            additionalClassPartsProvider, platformDependentDeclarationFilter,
+            BuiltInSerializerProtocol.extensionRegistry
+        )
+    }
+
+    override fun findPackage(fqName: FqName): DeserializedPackageFragment? =
+        finder.findBuiltInsData(fqName)?.let { inputStream ->
+            BuiltInsPackageFragmentImpl(fqName, storageManager, moduleDescriptor, inputStream)
+        }
+}
@@ -1,24 +1,11 @@
 /*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
 */

-package org.jetbrains.kotlin.load.kotlin
+package org.jetbrains.kotlin.builtins.jvm

 import org.jetbrains.kotlin.builtins.BuiltInsInitializer
-import org.jetbrains.kotlin.builtins.CloneableClassScope
-import org.jetbrains.kotlin.builtins.JvmBuiltInClassDescriptorFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl
@@ -31,11 +18,12 @@ import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.components.JavaResolverCache
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaClassDescriptor
+import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents
+import org.jetbrains.kotlin.load.kotlin.computeJvmDescriptor
+import org.jetbrains.kotlin.load.kotlin.signatures
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.platform.createMappedTypeParametersSubstitution
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
@@ -54,10 +42,10 @@ import java.io.Serializable
 import java.util.*

 open class JvmBuiltInsSettings(
-        private val moduleDescriptor: ModuleDescriptor,
-        storageManager: StorageManager,
-        deferredOwnerModuleDescriptor: () -> ModuleDescriptor,
-        isAdditionalBuiltInsFeatureSupported: () -> Boolean
+    private val moduleDescriptor: ModuleDescriptor,
+    storageManager: StorageManager,
+    deferredOwnerModuleDescriptor: () -> ModuleDescriptor,
+    isAdditionalBuiltInsFeatureSupported: () -> Boolean
 ) : AdditionalClassPartsProvider, PlatformDependentDeclarationFilter {
    private val j2kClassMap = JavaToKotlinClassMap

@@ -67,8 +55,8 @@ open class JvmBuiltInsSettings(
    private val mockSerializableType = storageManager.createMockJavaIoSerializableType()
    private val cloneableType by storageManager.createLazyValue {
        ownerModuleDescriptor.findNonGenericClassAcrossDependencies(
-                JvmBuiltInClassDescriptorFactory.CLONEABLE_CLASS_ID,
-                NotFoundClasses(storageManager, ownerModuleDescriptor)
+            JvmBuiltInClassDescriptorFactory.CLONEABLE_CLASS_ID,
+            NotFoundClasses(storageManager, ownerModuleDescriptor)
        ).defaultType
    }

@@ -77,7 +65,7 @@ open class JvmBuiltInsSettings(
    // Most this properties are lazy because they depends on KotlinBuiltIns initialization that depends on JvmBuiltInsSettings object
    private val notConsideredDeprecation by storageManager.createLazyValue {
        moduleDescriptor.builtIns.createDeprecatedAnnotation(
-                "This member is not fully supported by Kotlin compiler, so it may be absent or have different signature in next major version"
+            "This member is not fully supported by Kotlin compiler, so it may be absent or have different signature in next major version"
        ).let { AnnotationsImpl(listOf(it)) }
    }

@@ -90,8 +78,8 @@ open class JvmBuiltInsSettings(
        val superTypes = listOf(LazyWrappedType(this) { moduleDescriptor.builtIns.anyType })

        val mockSerializableClass = ClassDescriptorImpl(
-                mockJavaIoPackageFragment, Name.identifier("Serializable"), Modality.ABSTRACT, ClassKind.INTERFACE, superTypes,
-                SourceElement.NO_SOURCE, /* isExternal = */ false, this
+            mockJavaIoPackageFragment, Name.identifier("Serializable"), Modality.ABSTRACT, ClassKind.INTERFACE, superTypes,
+            SourceElement.NO_SOURCE, false, this
        )

        mockSerializableClass.initialize(MemberScope.Empty, emptySet(), null)
@@ -109,29 +97,32 @@ open class JvmBuiltInsSettings(

    override fun getFunctions(name: Name, classDescriptor: ClassDescriptor): Collection<SimpleFunctionDescriptor> {
        if (name == CloneableClassScope.CLONE_NAME && classDescriptor is DeserializedClassDescriptor &&
-            KotlinBuiltIns.isArrayOrPrimitiveArray(classDescriptor)) {
+            KotlinBuiltIns.isArrayOrPrimitiveArray(classDescriptor)
+        ) {
            // Do not create clone for arrays deserialized from metadata in the old (1.0) runtime, because clone is declared there anyway
            if (classDescriptor.classProto.functionList.any { functionProto ->
-                classDescriptor.c.nameResolver.getName(functionProto.name) == CloneableClassScope.CLONE_NAME
-            }) {
+                    classDescriptor.c.nameResolver.getName(functionProto.name) == CloneableClassScope.CLONE_NAME
+                }) {
                return emptyList()
            }
-            return listOf(createCloneForArray(
+            return listOf(
+                createCloneForArray(
                    classDescriptor, cloneableType.memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BUILTINS).single()
-            ))
+                )
+            )
        }

        if (!isAdditionalBuiltInsFeatureSupported) return emptyList()

        return getAdditionalFunctions(classDescriptor) {
            it.getContributedFunctions(name, NoLookupLocation.FROM_BUILTINS)
-        }.mapNotNull {
-            additionalMember ->
+        }.mapNotNull { additionalMember ->
            val substitutedWithKotlinTypeParameters =
-                    additionalMember.substitute(
-                            createMappedTypeParametersSubstitution(
-                                    additionalMember.containingDeclaration as ClassDescriptor, classDescriptor).buildSubstitutor()
-                    ) as SimpleFunctionDescriptor
+                additionalMember.substitute(
+                    createMappedTypeParametersSubstitution(
+                        additionalMember.containingDeclaration as ClassDescriptor, classDescriptor
+                    ).buildSubstitutor()
+                ) as SimpleFunctionDescriptor

            substitutedWithKotlinTypeParameters.newCopyBuilder().apply {
                setOwner(classDescriptor)
@@ -167,8 +158,8 @@ open class JvmBuiltInsSettings(
    }

    private fun getAdditionalFunctions(
-            classDescriptor: ClassDescriptor,
-            functionsByScope: (MemberScope) -> Collection<SimpleFunctionDescriptor>
+        classDescriptor: ClassDescriptor,
+        functionsByScope: (MemberScope) -> Collection<SimpleFunctionDescriptor>
    ): Collection<SimpleFunctionDescriptor> {
        val javaAnalogueDescriptor = classDescriptor.getJavaAnalogue() ?: return emptyList()

@@ -180,29 +171,30 @@ open class JvmBuiltInsSettings(

        val fakeJavaClassDescriptor = javaAnalogueClassesWithCustomSupertypeCache.computeIfAbsent(javaAnalogueDescriptor.fqNameSafe) {
            javaAnalogueDescriptor.copy(
-                    javaResolverCache = JavaResolverCache.EMPTY,
-                    additionalSupertypeClassDescriptor = kotlinMutableClassIfContainer)
+                javaResolverCache = JavaResolverCache.EMPTY,
+                additionalSupertypeClassDescriptor = kotlinMutableClassIfContainer
+            )
        }

        val scope = fakeJavaClassDescriptor.unsubstitutedMemberScope

        return functionsByScope(scope)
-                .filter { analogueMember ->
-                    if (analogueMember.kind != CallableMemberDescriptor.Kind.DECLARATION) return@filter false
-                    if (!analogueMember.visibility.isPublicAPI) return@filter false
-                    if (KotlinBuiltIns.isDeprecated(analogueMember)) return@filter false
+            .filter { analogueMember ->
+                if (analogueMember.kind != CallableMemberDescriptor.Kind.DECLARATION) return@filter false
+                if (!analogueMember.visibility.isPublicAPI) return@filter false
+                if (KotlinBuiltIns.isDeprecated(analogueMember)) return@filter false

-                    if (analogueMember.overriddenDescriptors.any {
+                if (analogueMember.overriddenDescriptors.any {
                        it.containingDeclaration.fqNameSafe in kotlinVersions
                    }) return@filter false

-                    !analogueMember.isMutabilityViolation(isMutable)
-                }
+                !analogueMember.isMutabilityViolation(isMutable)
+            }
    }

    private fun createCloneForArray(
-            arrayClassDescriptor: DeserializedClassDescriptor,
-            cloneFromCloneable: SimpleFunctionDescriptor
+        arrayClassDescriptor: DeserializedClassDescriptor,
+        cloneFromCloneable: SimpleFunctionDescriptor
    ): SimpleFunctionDescriptor = cloneFromCloneable.newCopyBuilder().apply {
        setOwner(arrayClassDescriptor)
        setVisibility(Visibilities.PUBLIC)
@@ -217,12 +209,11 @@ open class JvmBuiltInsSettings(
        if ((SignatureBuildingComponents.signature(owner, jvmDescriptor) in MUTABLE_METHOD_SIGNATURES) xor isMutable) return true

        return DFS.ifAny<CallableMemberDescriptor>(
-                listOf(this),
-                { it.original.overriddenDescriptors }
-        ) {
-            overridden ->
+            listOf(this),
+            { it.original.overriddenDescriptors }
+        ) { overridden ->
            overridden.kind == CallableMemberDescriptor.Kind.DECLARATION &&
-                j2kClassMap.isMutable(overridden.containingDeclaration as ClassDescriptor)
+                    j2kClassMap.isMutable(overridden.containingDeclaration as ClassDescriptor)
        }
    }

@@ -231,29 +222,29 @@ open class JvmBuiltInsSettings(
        val jvmDescriptor = computeJvmDescriptor()
        var result: JDKMemberStatus? = null
        return DFS.dfs<ClassDescriptor, JDKMemberStatus>(
-                listOf(owner),
-                {
-                    // Search through mapped supertypes to determine that Set.toArray is in blacklist, while we have only
-                    // Collection.toArray there explicitly
-                    // Note, that we can't find j.u.Collection.toArray within overriddenDescriptors of j.u.Set.toArray
-                    it.typeConstructor.supertypes.mapNotNull {
-                        (it.constructor.declarationDescriptor?.original as? ClassDescriptor)?.getJavaAnalogue()
-                    }
-                },
-                object : DFS.AbstractNodeHandler<ClassDescriptor, JDKMemberStatus>() {
-                    override fun beforeChildren(javaClassDescriptor: ClassDescriptor): Boolean {
-                        val signature = SignatureBuildingComponents.signature(javaClassDescriptor, jvmDescriptor)
-                        when (signature) {
-                            in BLACK_LIST_METHOD_SIGNATURES -> { result = JDKMemberStatus.BLACK_LIST }
-                            in WHITE_LIST_METHOD_SIGNATURES -> { result = JDKMemberStatus.WHITE_LIST }
-                            in DROP_LIST_METHOD_SIGNATURES -> { result = JDKMemberStatus.DROP }
-                        }
-
-                        return result == null
+            listOf(owner),
+            {
+                // Search through mapped supertypes to determine that Set.toArray is in blacklist, while we have only
+                // Collection.toArray there explicitly
+                // Note, that we can't find j.u.Collection.toArray within overriddenDescriptors of j.u.Set.toArray
+                it.typeConstructor.supertypes.mapNotNull {
+                    (it.constructor.declarationDescriptor?.original as? ClassDescriptor)?.getJavaAnalogue()
+                }
+            },
+            object : DFS.AbstractNodeHandler<ClassDescriptor, JDKMemberStatus>() {
+                override fun beforeChildren(javaClassDescriptor: ClassDescriptor): Boolean {
+                    val signature = SignatureBuildingComponents.signature(javaClassDescriptor, jvmDescriptor)
+                    when (signature) {
+                        in BLACK_LIST_METHOD_SIGNATURES -> result = JDKMemberStatus.BLACK_LIST
+                        in WHITE_LIST_METHOD_SIGNATURES -> result = JDKMemberStatus.WHITE_LIST
+                        in DROP_LIST_METHOD_SIGNATURES -> result = JDKMemberStatus.DROP
                    }

-                    override fun result() = result ?: JDKMemberStatus.NOT_CONSIDERED
-                })
+                    return result == null
+                }
+
+                override fun result() = result ?: JDKMemberStatus.NOT_CONSIDERED
+            })
    }

    private enum class JDKMemberStatus {
@@ -281,29 +272,33 @@ open class JvmBuiltInsSettings(
        val javaAnalogueDescriptor = classDescriptor.getJavaAnalogue() ?: return emptyList()

        val defaultKotlinVersion =
-                j2kClassMap.mapJavaToKotlin(javaAnalogueDescriptor.fqNameSafe, FallbackBuiltIns.Instance) ?: return emptyList()
+            j2kClassMap.mapJavaToKotlin(javaAnalogueDescriptor.fqNameSafe, FallbackBuiltIns.Instance) ?: return emptyList()

        val substitutor = createMappedTypeParametersSubstitution(defaultKotlinVersion, javaAnalogueDescriptor).buildSubstitutor()

        fun ConstructorDescriptor.isEffectivelyTheSameAs(javaConstructor: ConstructorDescriptor) =
-                OverridingUtil.getBothWaysOverridability(this, javaConstructor.substitute(substitutor)) ==
+            OverridingUtil.getBothWaysOverridability(this, javaConstructor.substitute(substitutor)) ==
                    OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE

-        return javaAnalogueDescriptor.constructors.filter {
-            javaConstructor ->
+        return javaAnalogueDescriptor.constructors.filter { javaConstructor ->
            javaConstructor.visibility.isPublicAPI &&
-                defaultKotlinVersion.constructors.none { it.isEffectivelyTheSameAs(javaConstructor) } &&
-                !javaConstructor.isTrivialCopyConstructorFor(classDescriptor) &&
-                !KotlinBuiltIns.isDeprecated(javaConstructor) &&
-                SignatureBuildingComponents.signature(javaAnalogueDescriptor, javaConstructor.computeJvmDescriptor()) !in BLACK_LIST_CONSTRUCTOR_SIGNATURES
-        }.map {
-            javaConstructor ->
+                    defaultKotlinVersion.constructors.none { it.isEffectivelyTheSameAs(javaConstructor) } &&
+                    !javaConstructor.isTrivialCopyConstructorFor(classDescriptor) &&
+                    !KotlinBuiltIns.isDeprecated(javaConstructor) &&
+                    SignatureBuildingComponents.signature(
+                        javaAnalogueDescriptor,
+                        javaConstructor.computeJvmDescriptor()
+                    ) !in BLACK_LIST_CONSTRUCTOR_SIGNATURES
+        }.map { javaConstructor ->
            javaConstructor.newCopyBuilder().apply {
                setOwner(classDescriptor)
                setReturnType(classDescriptor.defaultType)
                setPreserveSourceElement()
                setSubstitution(substitutor.substitution)
-                if (SignatureBuildingComponents.signature(javaAnalogueDescriptor, javaConstructor.computeJvmDescriptor()) !in WHITE_LIST_CONSTRUCTOR_SIGNATURES) {
+                if (SignatureBuildingComponents.signature(
+                        javaAnalogueDescriptor, javaConstructor.computeJvmDescriptor()
+                    ) !in WHITE_LIST_CONSTRUCTOR_SIGNATURES
+                ) {
                    setAdditionalAnnotations(notConsideredDeprecation)
                }

@@ -319,14 +314,14 @@ open class JvmBuiltInsSettings(

        val jvmDescriptor = functionDescriptor.computeJvmDescriptor()
        return javaAnalogueClassDescriptor
-                    .unsubstitutedMemberScope
-                    .getContributedFunctions(functionDescriptor.name, NoLookupLocation.FROM_BUILTINS)
-                    .any { it.computeJvmDescriptor() == jvmDescriptor }
+            .unsubstitutedMemberScope
+            .getContributedFunctions(functionDescriptor.name, NoLookupLocation.FROM_BUILTINS)
+            .any { it.computeJvmDescriptor() == jvmDescriptor }
    }

    private fun ConstructorDescriptor.isTrivialCopyConstructorFor(classDescriptor: ClassDescriptor): Boolean =
-            valueParameters.size == 1 &&
-            valueParameters.single().type.constructor.declarationDescriptor?.fqNameUnsafe == classDescriptor.fqNameUnsafe
+        valueParameters.size == 1 &&
+                valueParameters.single().type.constructor.declarationDescriptor?.fqNameUnsafe == classDescriptor.fqNameUnsafe

    companion object {
        fun isSerializableInJava(fqName: FqNameUnsafe): Boolean {
@@ -336,8 +331,7 @@ open class JvmBuiltInsSettings(
            val javaClassId = JavaToKotlinClassMap.mapKotlinToJava(fqName) ?: return false
            val classViaReflection = try {
                Class.forName(javaClassId.asSingleFqName().asString())
-            }
-            catch (e: ClassNotFoundException) {
+            } catch (e: ClassNotFoundException) {
                return false
            }
            return Serializable::class.java.isAssignableFrom(classViaReflection)
@@ -348,41 +342,42 @@ open class JvmBuiltInsSettings(
        }

        val DROP_LIST_METHOD_SIGNATURES: Set<String> =
-                SignatureBuildingComponents.inJavaUtil(
-                        "Collection",
-                        "toArray()[Ljava/lang/Object;", "toArray([Ljava/lang/Object;)[Ljava/lang/Object;") +
-
-                "java/lang/annotation/Annotation.annotationType()Ljava/lang/Class;"
+            SignatureBuildingComponents.inJavaUtil(
+                "Collection",
+                "toArray()[Ljava/lang/Object;", "toArray([Ljava/lang/Object;)[Ljava/lang/Object;"
+            ) + "java/lang/annotation/Annotation.annotationType()Ljava/lang/Class;"

        val BLACK_LIST_METHOD_SIGNATURES: Set<String> =
            signatures {
                buildPrimitiveValueMethodsSet() +

-                inJavaUtil("List", "sort(Ljava/util/Comparator;)V") +
+                        inJavaUtil("List", "sort(Ljava/util/Comparator;)V") +

-                inJavaLang("String",
-                           "codePointAt(I)I", "codePointBefore(I)I", "codePointCount(II)I", "compareToIgnoreCase(Ljava/lang/String;)I",
-                           "concat(Ljava/lang/String;)Ljava/lang/String;", "contains(Ljava/lang/CharSequence;)Z",
-                           "contentEquals(Ljava/lang/CharSequence;)Z", "contentEquals(Ljava/lang/StringBuffer;)Z",
-                           "endsWith(Ljava/lang/String;)Z", "equalsIgnoreCase(Ljava/lang/String;)Z", "getBytes()[B", "getBytes(II[BI)V",
-                           "getBytes(Ljava/lang/String;)[B", "getBytes(Ljava/nio/charset/Charset;)[B", "getChars(II[CI)V",
-                           "indexOf(I)I", "indexOf(II)I", "indexOf(Ljava/lang/String;)I", "indexOf(Ljava/lang/String;I)I",
-                           "intern()Ljava/lang/String;", "isEmpty()Z", "lastIndexOf(I)I", "lastIndexOf(II)I",
-                           "lastIndexOf(Ljava/lang/String;)I", "lastIndexOf(Ljava/lang/String;I)I", "matches(Ljava/lang/String;)Z",
-                           "offsetByCodePoints(II)I", "regionMatches(ILjava/lang/String;II)Z", "regionMatches(ZILjava/lang/String;II)Z",
-                           "replaceAll(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;", "replace(CC)Ljava/lang/String;",
-                           "replaceFirst(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
-                           "replace(Ljava/lang/CharSequence;Ljava/lang/CharSequence;)Ljava/lang/String;",
-                           "split(Ljava/lang/String;I)[Ljava/lang/String;", "split(Ljava/lang/String;)[Ljava/lang/String;",
-                           "startsWith(Ljava/lang/String;I)Z", "startsWith(Ljava/lang/String;)Z", "substring(II)Ljava/lang/String;",
-                           "substring(I)Ljava/lang/String;", "toCharArray()[C", "toLowerCase()Ljava/lang/String;",
-                           "toLowerCase(Ljava/util/Locale;)Ljava/lang/String;", "toUpperCase()Ljava/lang/String;",
-                           "toUpperCase(Ljava/util/Locale;)Ljava/lang/String;", "trim()Ljava/lang/String;") +
+                        inJavaLang(
+                            "String",
+                            "codePointAt(I)I", "codePointBefore(I)I", "codePointCount(II)I", "compareToIgnoreCase(Ljava/lang/String;)I",
+                            "concat(Ljava/lang/String;)Ljava/lang/String;", "contains(Ljava/lang/CharSequence;)Z",
+                            "contentEquals(Ljava/lang/CharSequence;)Z", "contentEquals(Ljava/lang/StringBuffer;)Z",
+                            "endsWith(Ljava/lang/String;)Z", "equalsIgnoreCase(Ljava/lang/String;)Z", "getBytes()[B", "getBytes(II[BI)V",
+                            "getBytes(Ljava/lang/String;)[B", "getBytes(Ljava/nio/charset/Charset;)[B", "getChars(II[CI)V",
+                            "indexOf(I)I", "indexOf(II)I", "indexOf(Ljava/lang/String;)I", "indexOf(Ljava/lang/String;I)I",
+                            "intern()Ljava/lang/String;", "isEmpty()Z", "lastIndexOf(I)I", "lastIndexOf(II)I",
+                            "lastIndexOf(Ljava/lang/String;)I", "lastIndexOf(Ljava/lang/String;I)I", "matches(Ljava/lang/String;)Z",
+                            "offsetByCodePoints(II)I", "regionMatches(ILjava/lang/String;II)Z", "regionMatches(ZILjava/lang/String;II)Z",
+                            "replaceAll(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;", "replace(CC)Ljava/lang/String;",
+                            "replaceFirst(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+                            "replace(Ljava/lang/CharSequence;Ljava/lang/CharSequence;)Ljava/lang/String;",
+                            "split(Ljava/lang/String;I)[Ljava/lang/String;", "split(Ljava/lang/String;)[Ljava/lang/String;",
+                            "startsWith(Ljava/lang/String;I)Z", "startsWith(Ljava/lang/String;)Z", "substring(II)Ljava/lang/String;",
+                            "substring(I)Ljava/lang/String;", "toCharArray()[C", "toLowerCase()Ljava/lang/String;",
+                            "toLowerCase(Ljava/util/Locale;)Ljava/lang/String;", "toUpperCase()Ljava/lang/String;",
+                            "toUpperCase(Ljava/util/Locale;)Ljava/lang/String;", "trim()Ljava/lang/String;"
+                        ) +

-                inJavaLang("Double", "isInfinite()Z", "isNaN()Z") +
-                inJavaLang("Float", "isInfinite()Z", "isNaN()Z") +
+                        inJavaLang("Double", "isInfinite()Z", "isNaN()Z") +
+                        inJavaLang("Float", "isInfinite()Z", "isNaN()Z") +

-                inJavaLang("Enum", "getDeclaringClass()Ljava/lang/Class;", "finalize()V")
+                        inJavaLang("Enum", "getDeclaringClass()Ljava/lang/Class;", "finalize()V")
            }

        private fun buildPrimitiveValueMethodsSet(): Set<String> =
@@ -393,83 +388,102 @@ open class JvmBuiltInsSettings(
            }

        val WHITE_LIST_METHOD_SIGNATURES: Set<String> =
-                signatures {
-                    inJavaLang("CharSequence",
-                            "codePoints()Ljava/util/stream/IntStream;", "chars()Ljava/util/stream/IntStream;") +
+            signatures {
+                inJavaLang(
+                    "CharSequence",
+                    "codePoints()Ljava/util/stream/IntStream;", "chars()Ljava/util/stream/IntStream;"
+                ) +

-                    inJavaUtil("Iterator",
-                               "forEachRemaining(Ljava/util/function/Consumer;)V") +
+                        inJavaUtil(
+                            "Iterator",
+                            "forEachRemaining(Ljava/util/function/Consumer;)V"
+                        ) +

-                    inJavaLang("Iterable",
-                               "forEach(Ljava/util/function/Consumer;)V", "spliterator()Ljava/util/Spliterator;") +
+                        inJavaLang(
+                            "Iterable",
+                            "forEach(Ljava/util/function/Consumer;)V", "spliterator()Ljava/util/Spliterator;"
+                        ) +

-                    inJavaLang("Throwable",
-                               "setStackTrace([Ljava/lang/StackTraceElement;)V", "fillInStackTrace()Ljava/lang/Throwable;",
-                               "getLocalizedMessage()Ljava/lang/String;", "printStackTrace()V", "printStackTrace(Ljava/io/PrintStream;)V",
-                               "printStackTrace(Ljava/io/PrintWriter;)V", "getStackTrace()[Ljava/lang/StackTraceElement;",
-                               "initCause(Ljava/lang/Throwable;)Ljava/lang/Throwable;", "getSuppressed()[Ljava/lang/Throwable;",
-                               "addSuppressed(Ljava/lang/Throwable;)V") +
+                        inJavaLang(
+                            "Throwable",
+                            "setStackTrace([Ljava/lang/StackTraceElement;)V", "fillInStackTrace()Ljava/lang/Throwable;",
+                            "getLocalizedMessage()Ljava/lang/String;", "printStackTrace()V", "printStackTrace(Ljava/io/PrintStream;)V",
+                            "printStackTrace(Ljava/io/PrintWriter;)V", "getStackTrace()[Ljava/lang/StackTraceElement;",
+                            "initCause(Ljava/lang/Throwable;)Ljava/lang/Throwable;", "getSuppressed()[Ljava/lang/Throwable;",
+                            "addSuppressed(Ljava/lang/Throwable;)V"
+                        ) +

-                    inJavaUtil("Collection",
-                               "spliterator()Ljava/util/Spliterator;", "parallelStream()Ljava/util/stream/Stream;",
-                               "stream()Ljava/util/stream/Stream;", "removeIf(Ljava/util/function/Predicate;)Z") +
+                        inJavaUtil(
+                            "Collection",
+                            "spliterator()Ljava/util/Spliterator;", "parallelStream()Ljava/util/stream/Stream;",
+                            "stream()Ljava/util/stream/Stream;", "removeIf(Ljava/util/function/Predicate;)Z"
+                        ) +

-                    inJavaUtil("List",
-                               "replaceAll(Ljava/util/function/UnaryOperator;)V") +
+                        inJavaUtil(
+                            "List",
+                            "replaceAll(Ljava/util/function/UnaryOperator;)V"
+                        ) +

-                    inJavaUtil("Map",
-                               "getOrDefault(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
-                               "forEach(Ljava/util/function/BiConsumer;)V", "replaceAll(Ljava/util/function/BiFunction;)V",
-                               "merge(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
-                               "computeIfPresent(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
-                               "putIfAbsent(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
-                               "replace(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z",
-                               "replace(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
-                               "computeIfAbsent(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;",
-                               "compute(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;")
-                }
+                        inJavaUtil(
+                            "Map",
+                            "getOrDefault(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+                            "forEach(Ljava/util/function/BiConsumer;)V", "replaceAll(Ljava/util/function/BiFunction;)V",
+                            "merge(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+                            "computeIfPresent(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+                            "putIfAbsent(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+                            "replace(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z",
+                            "replace(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+                            "computeIfAbsent(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;",
+                            "compute(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;"
+                        )
+            }

        val MUTABLE_METHOD_SIGNATURES: Set<String> =
            signatures {
                inJavaUtil("Collection", "removeIf(Ljava/util/function/Predicate;)Z") +

-                inJavaUtil("List", "replaceAll(Ljava/util/function/UnaryOperator;)V", "sort(Ljava/util/Comparator;)V") +
+                        inJavaUtil("List", "replaceAll(Ljava/util/function/UnaryOperator;)V", "sort(Ljava/util/Comparator;)V") +

-                inJavaUtil("Map",
-                           "computeIfAbsent(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;",
-                           "computeIfPresent(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
-                           "compute(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
-                           "merge(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
-                           "putIfAbsent(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
-                           "remove(Ljava/lang/Object;Ljava/lang/Object;)Z", "replaceAll(Ljava/util/function/BiFunction;)V",
-                           "replace(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
-                           "replace(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z")
+                        inJavaUtil(
+                            "Map",
+                            "computeIfAbsent(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;",
+                            "computeIfPresent(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+                            "compute(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+                            "merge(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+                            "putIfAbsent(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+                            "remove(Ljava/lang/Object;Ljava/lang/Object;)Z", "replaceAll(Ljava/util/function/BiFunction;)V",
+                            "replace(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+                            "replace(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z"
+                        )
            }

        val BLACK_LIST_CONSTRUCTOR_SIGNATURES: Set<String> =
            signatures {
                buildPrimitiveStringConstructorsSet() +
-                inJavaLang("Float", *constructors("D")) +
-                inJavaLang("String", *constructors(
-                        "[C", "[CII", "[III", "[BIILjava/lang/String;",
-                        "[BIILjava/nio/charset/Charset;",
-                        "[BLjava/lang/String;",
-                        "[BLjava/nio/charset/Charset;",
-                        "[BII", "[B",
-                        "Ljava/lang/StringBuffer;",
-                        "Ljava/lang/StringBuilder;"
-                ))
+                        inJavaLang("Float", *constructors("D")) +
+                        inJavaLang(
+                            "String", *constructors(
+                                "[C", "[CII", "[III", "[BIILjava/lang/String;",
+                                "[BIILjava/nio/charset/Charset;",
+                                "[BLjava/lang/String;",
+                                "[BLjava/nio/charset/Charset;",
+                                "[BII", "[B",
+                                "Ljava/lang/StringBuffer;",
+                                "Ljava/lang/StringBuilder;"
+                            )
+                        )
            }

        val WHITE_LIST_CONSTRUCTOR_SIGNATURES: Set<String> =
-                signatures {
-                    inJavaLang("Throwable", *constructors("Ljava/lang/String;Ljava/lang/Throwable;ZZ"))
-                }
+            signatures {
+                inJavaLang("Throwable", *constructors("Ljava/lang/String;Ljava/lang/Throwable;ZZ"))
+            }

        private fun buildPrimitiveStringConstructorsSet(): Set<String> =
            signatures {
-                listOf(JvmPrimitiveType.BOOLEAN, JvmPrimitiveType.BYTE, JvmPrimitiveType.DOUBLE, JvmPrimitiveType.FLOAT,
-                      JvmPrimitiveType.BYTE, JvmPrimitiveType.INT, JvmPrimitiveType.LONG, JvmPrimitiveType.SHORT
+                listOf(
+                    JvmPrimitiveType.BOOLEAN, JvmPrimitiveType.BYTE, JvmPrimitiveType.DOUBLE, JvmPrimitiveType.FLOAT,
+                    JvmPrimitiveType.BYTE, JvmPrimitiveType.INT, JvmPrimitiveType.LONG, JvmPrimitiveType.SHORT
                ).flatMapTo(LinkedHashSet()) {
                    // java/lang/<Wrapper>.<init>(Ljava/lang/String;)V
                    inJavaLang(it.wrapperFqName.shortName().asString(), *constructors("Ljava/lang/String;"))
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.builtins.jvm
+
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.types.TypeConstructorSubstitution
+import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
+
+fun createMappedTypeParametersSubstitution(from: ClassDescriptor, to: ClassDescriptor): TypeConstructorSubstitution {
+    assert(from.declaredTypeParameters.size == to.declaredTypeParameters.size) {
+        "$from and $to should have same number of type parameters, " +
+                "but ${from.declaredTypeParameters.size} / ${to.declaredTypeParameters.size} found"
+    }
+
+    return TypeConstructorSubstitution.createByConstructorsMap(
+        from.declaredTypeParameters.map(TypeParameterDescriptor::getTypeConstructor).zip(
+            to.declaredTypeParameters.map { it.defaultType.asTypeProjection() }
+        ).toMap())
+}
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.load.java.lazy.descriptors

+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.findNonGenericClassAcrossDependencies
@@ -29,7 +30,6 @@ import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.constants.*
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.load.java.lazy.descriptors

 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.jvm.createMappedTypeParametersSubstitution
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase
@@ -26,7 +27,6 @@ import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
 import org.jetbrains.kotlin.load.java.structure.JavaType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.isValidJavaFqName
-import org.jetbrains.kotlin.platform.createMappedTypeParametersSubstitution
 import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.load.java.lazy.types

+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.load.java.components.TypeUsage
@@ -28,7 +29,6 @@ import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeFlexibility.*
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.Variance.*
 import org.jetbrains.kotlin.types.typeUtil.createProjection
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.load.java.typeEnhancement

+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
@@ -29,7 +30,6 @@ import org.jetbrains.kotlin.load.java.lazy.descriptors.isJavaField
 import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents
 import org.jetbrains.kotlin.load.kotlin.computeJvmDescriptor
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.firstArgument
 import org.jetbrains.kotlin.types.*
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.load.java.typeEnhancement

+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.SourceElement
@@ -31,7 +32,6 @@ import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifier.NOT_N
 import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifier.NULLABLE
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.createProjection
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.load.kotlin

+import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.NotFoundClasses
 import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentDeclara
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
-import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.serialization.deserialization.*
 import org.jetbrains.kotlin.storage.StorageManager

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.load.kotlin

 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature
 import org.jetbrains.kotlin.load.java.isFromJavaOrBuiltins
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.load.kotlin

 import org.jetbrains.kotlin.builtins.*
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.load.java.typeEnhancement.hasEnhancedNullability
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.isInlineClassType
@@ -1,34 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.platform
-
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.types.TypeConstructorSubstitution
-import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
-
-fun createMappedTypeParametersSubstitution(from: ClassDescriptor, to: ClassDescriptor): TypeConstructorSubstitution {
-    assert(from.declaredTypeParameters.size == to.declaredTypeParameters.size) {
-        "$from and $to should have same number of type parameters, " +
-        "but ${from.declaredTypeParameters.size} / ${to.declaredTypeParameters.size} found"
-    }
-
-    return TypeConstructorSubstitution.createByConstructorsMap(
-            from.declaredTypeParameters.map(TypeParameterDescriptor::getTypeConstructor).zip(
-                    to.declaredTypeParameters.map { it.defaultType.asTypeProjection() }
-            ).toMap())
-}