Drop ClassData and PackageData, rename ClassDataWithSource -> ClassData

Use pairs in JvmProtoBufUtil for simplicity
2018-03-01 18:45:00 +01:00
parent 5ed5ac8291
commit 0ba42850f9
15 changed files with 68 additions and 104 deletions
@@ -41,12 +41,11 @@ data class PackagePartProtoData(val proto: ProtoBuf.Package, val nameResolver: N

 fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
    if (isPackageFacade) {
-        val packageData = JvmProtoBufUtil.readPackageDataFrom(bytes, strings)
-        PackagePartProtoData(packageData.packageProto, packageData.nameResolver, packageFqName)
-    }
-    else {
-        val classData = JvmProtoBufUtil.readClassDataFrom(bytes, strings)
-        ClassProtoData(classData.classProto, classData.nameResolver)
+        val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(bytes, strings)
+        PackagePartProtoData(packageProto, nameResolver, packageFqName)
+    } else {
+        val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(bytes, strings)
+        ClassProtoData(classProto, nameResolver)
    }

 internal val MessageLite.isPrivate: Boolean
@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.codegen.serialization.JvmStringTable
 import org.jetbrains.kotlin.codegen.writeKotlinMetadata
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass
-import org.jetbrains.kotlin.load.kotlin.JvmNameResolver
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor
 import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
@@ -203,7 +202,7 @@ class AnonymousObjectTransformer(
        when (header.kind) {
            KotlinClassHeader.Kind.CLASS -> {
                val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(data, strings)
-                val newStringTable = JvmStringTable(state.typeMapper, nameResolver as JvmNameResolver)
+                val newStringTable = JvmStringTable(state.typeMapper, nameResolver)
                val newProto = classProto.toBuilder().apply {
                    setExtension(JvmProtoBuf.anonymousObjectOriginName, newStringTable.getStringIndex(oldObjectType.internalName))
                }.build()
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.serialization.ClassDataWithSource
+import org.jetbrains.kotlin.serialization.deserialization.ClassData
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
 import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
@@ -45,14 +45,14 @@ class DeserializedDescriptorResolver {
        return components.classDeserializer.deserializeClass(kotlinClass.classId, classData)
    }

-    internal fun readClassData(kotlinClass: KotlinJvmBinaryClass): ClassDataWithSource? {
+    internal fun readClassData(kotlinClass: KotlinJvmBinaryClass): ClassData? {
        val data = readData(kotlinClass, KOTLIN_CLASS) ?: return null
        val strings = kotlinClass.classHeader.strings ?: return null
-        val classData = parseProto(kotlinClass) {
+        val (nameResolver, classProto) = parseProto(kotlinClass) {
            JvmProtoBufUtil.readClassDataFrom(data, strings)
        } ?: return null
        val source = KotlinJvmBinarySourceElement(kotlinClass, kotlinClass.incompatibility, kotlinClass.isPreReleaseInvisible)
-        return ClassDataWithSource(classData, source)
+        return ClassData(nameResolver, classProto, source)
    }

    fun createKotlinPackagePartScope(descriptor: PackageFragmentDescriptor, kotlinClass: KotlinJvmBinaryClass): MemberScope? {
@@ -17,14 +17,14 @@
 package org.jetbrains.kotlin.load.kotlin

 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.ClassDataWithSource
+import org.jetbrains.kotlin.serialization.deserialization.ClassData
 import org.jetbrains.kotlin.serialization.deserialization.ClassDataFinder

 class JavaClassDataFinder(
        internal val kotlinClassFinder: KotlinClassFinder,
        private val deserializedDescriptorResolver: DeserializedDescriptorResolver
 ) : ClassDataFinder {
-    override fun findClassData(classId: ClassId): ClassDataWithSource? {
+    override fun findClassData(classId: ClassId): ClassData? {
        val kotlinClass = kotlinClassFinder.findKotlinClass(classId) ?: return null
        assert(kotlinClass.classId == classId) {
            "Class with incorrect id found: expected $classId, actual ${kotlinClass.classId}"
@@ -20,8 +20,6 @@ import org.jetbrains.kotlin.load.kotlin.JvmNameResolver
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite
-import org.jetbrains.kotlin.serialization.ClassData
-import org.jetbrains.kotlin.serialization.PackageData
 import org.jetbrains.kotlin.serialization.deserialization.*
 import java.io.ByteArrayInputStream
 import java.io.InputStream
@@ -30,23 +28,23 @@ object JvmProtoBufUtil {
    val EXTENSION_REGISTRY: ExtensionRegistryLite = ExtensionRegistryLite.newInstance().apply(JvmProtoBuf::registerAllExtensions)

    @JvmStatic
-    fun readClassDataFrom(data: Array<String>, strings: Array<String>): ClassData =
+    fun readClassDataFrom(data: Array<String>, strings: Array<String>): Pair<JvmNameResolver, ProtoBuf.Class> =
        readClassDataFrom(BitEncoding.decodeBytes(data), strings)

    @JvmStatic
-    fun readClassDataFrom(bytes: ByteArray, strings: Array<String>): ClassData {
+    fun readClassDataFrom(bytes: ByteArray, strings: Array<String>): Pair<JvmNameResolver, ProtoBuf.Class> {
        val input = ByteArrayInputStream(bytes)
-        return ClassData(input.readNameResolver(strings), ProtoBuf.Class.parseFrom(input, EXTENSION_REGISTRY))
+        return Pair(input.readNameResolver(strings), ProtoBuf.Class.parseFrom(input, EXTENSION_REGISTRY))
    }

    @JvmStatic
-    fun readPackageDataFrom(data: Array<String>, strings: Array<String>): PackageData =
+    fun readPackageDataFrom(data: Array<String>, strings: Array<String>): Pair<JvmNameResolver, ProtoBuf.Package> =
        readPackageDataFrom(BitEncoding.decodeBytes(data), strings)

    @JvmStatic
-    fun readPackageDataFrom(bytes: ByteArray, strings: Array<String>): PackageData {
+    fun readPackageDataFrom(bytes: ByteArray, strings: Array<String>): Pair<JvmNameResolver, ProtoBuf.Package> {
        val input = ByteArrayInputStream(bytes)
-        return PackageData(input.readNameResolver(strings), ProtoBuf.Package.parseFrom(input, EXTENSION_REGISTRY))
+        return Pair(input.readNameResolver(strings), ProtoBuf.Package.parseFrom(input, EXTENSION_REGISTRY))
    }

    @JvmStatic
@@ -1,36 +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.serialization
-
-import org.jetbrains.kotlin.descriptors.SourceElement
-import org.jetbrains.kotlin.metadata.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver
-
-data class ClassData(
-        val nameResolver: NameResolver,
-        val classProto: ProtoBuf.Class
-)
-
-data class ClassDataWithSource(
-        val classData: ClassData,
-        val sourceElement: SourceElement
-)
-
-data class PackageData(
-        val nameResolver: NameResolver,
-        val packageProto: ProtoBuf.Package
-)
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2000-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.serialization.deserialization
+
+import org.jetbrains.kotlin.descriptors.SourceElement
+import org.jetbrains.kotlin.metadata.ProtoBuf
+
+data class ClassData(
+    val nameResolver: NameResolver,
+    val classProto: ProtoBuf.Class,
+    val sourceElement: SourceElement
+)
@@ -19,9 +19,8 @@ package org.jetbrains.kotlin.serialization.deserialization;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.name.ClassId;
-import org.jetbrains.kotlin.serialization.ClassDataWithSource;

 public interface ClassDataFinder {
    @Nullable
-    ClassDataWithSource findClassData(@NotNull ClassId classId);
+    ClassData findClassData(@NotNull ClassId classId);
 }
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.serialization.deserialization
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.ClassDataWithSource
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.VersionRequirementTable

@@ -27,10 +26,10 @@ class ClassDeserializer(private val components: DeserializationComponents) {
    private val classes: (ClassKey) -> ClassDescriptor? =
            components.storageManager.createMemoizedFunctionWithNullableValues { key -> createClass(key) }

-    // Additional ClassDataWithSource parameter is needed to avoid calling ClassDataFinder#findClassData()
+    // Additional ClassData parameter is needed to avoid calling ClassDataFinder#findClassData()
    // if it is already computed at the call site
-    fun deserializeClass(classId: ClassId, classDataWithSource: ClassDataWithSource? = null): ClassDescriptor? =
-            classes(ClassKey(classId, classDataWithSource))
+    fun deserializeClass(classId: ClassId, classData: ClassData? = null): ClassDescriptor? =
+        classes(ClassKey(classId, classData))

    private fun createClass(key: ClassKey): ClassDescriptor? {
        val classId = key.classId
@@ -39,10 +38,9 @@ class ClassDeserializer(private val components: DeserializationComponents) {
        }
        if (classId in BLACK_LIST) return null

-        val (classData, sourceElement) = key.classDataWithSource
-                                         ?: components.classDataFinder.findClassData(classId)
-                                         ?: return null
-        val (nameResolver, classProto) = classData
+        val (nameResolver, classProto, sourceElement) = key.classData
+                ?: components.classDataFinder.findClassData(classId)
+                ?: return null

        val outerClassId = classId.outerClassId
        val outerContext = if (outerClassId != null) {
@@ -69,8 +67,8 @@ class ClassDeserializer(private val components: DeserializationComponents) {
        return DeserializedClassDescriptor(outerContext, classProto, nameResolver, sourceElement)
    }

-    private class ClassKey(val classId: ClassId, val classDataWithSource: ClassDataWithSource?) {
-        // classDataWithSource *intentionally* not used in equals() / hashCode()
+    private class ClassKey(val classId: ClassId, val classData: ClassData?) {
+        // classData *intentionally* not used in equals() / hashCode()
        override fun equals(other: Any?) = other is ClassKey && classId == other.classId

        override fun hashCode() = classId.hashCode()
@@ -18,10 +18,9 @@ package org.jetbrains.kotlin.serialization.deserialization

 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.ClassDataWithSource

 class DeserializedClassDataFinder(private val packageFragmentProvider: PackageFragmentProvider) : ClassDataFinder {
-    override fun findClassData(classId: ClassId): ClassDataWithSource? {
+    override fun findClassData(classId: ClassId): ClassData? {
        val packageFragments = packageFragmentProvider.getPackageFragments(classId.packageFqName)
        for (fragment in packageFragments) {
            if (fragment !is DeserializedPackageFragment) continue
@@ -31,8 +31,6 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.ChainedMemberScope
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.serialization.ClassData
-import org.jetbrains.kotlin.serialization.ClassDataWithSource
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.kotlin.storage.StorageManager
 import java.io.InputStream
@@ -84,7 +82,7 @@ class MetadataPackageFragment(
        message.class_List.firstOrNull { classProto ->
            nameResolver.getClassId(classProto.fqName) == classId
        }?.let { classProto ->
-            ClassDataWithSource(ClassData(nameResolver, classProto), SourceElement.NO_SOURCE)
+            ClassData(nameResolver, classProto, SourceElement.NO_SOURCE)
        }
    }

@@ -19,8 +19,6 @@ package org.jetbrains.kotlin.serialization.deserialization
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.ClassData
-import org.jetbrains.kotlin.serialization.ClassDataWithSource

 class ProtoBasedClassDataFinder(
        proto: ProtoBuf.PackageFragment,
@@ -34,8 +32,8 @@ class ProtoBasedClassDataFinder(

    internal val allClassIds: Collection<ClassId> get() = classIdToProto.keys

-    override fun findClassData(classId: ClassId): ClassDataWithSource? {
+    override fun findClassData(classId: ClassId): ClassData? {
        val classProto = classIdToProto[classId] ?: return null
-        return ClassDataWithSource(ClassData(nameResolver, classProto), classSource(classId))
+        return ClassData(nameResolver, classProto, classSource(classId))
    }
 }
@@ -19,11 +19,12 @@ package kotlin.reflect.jvm.internal
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageFragment
+import org.jetbrains.kotlin.load.kotlin.JvmNameResolver
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryPackageSourceElement
+import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.serialization.PackageData
 import org.jetbrains.kotlin.serialization.deserialization.MemberDeserializer
 import org.jetbrains.kotlin.serialization.deserialization.TypeTable
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
@@ -62,7 +63,7 @@ internal class KPackageImpl(
            }
        }

-        val metadata: PackageData? by ReflectProperties.lazy {
+        val metadata: Pair<JvmNameResolver, ProtoBuf.Package>? by ReflectProperties.lazy {
            kotlinClass?.classHeader?.let { header ->
                val data = header.data
                val strings = header.strings
@@ -34,11 +34,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
-import org.jetbrains.kotlin.serialization.ClassDataWithSource
-import org.jetbrains.kotlin.serialization.deserialization.ClassDataFinder
-import org.jetbrains.kotlin.serialization.deserialization.ContractDeserializer
-import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
-import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
+import org.jetbrains.kotlin.serialization.deserialization.*
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 import java.io.InputStream
@@ -134,7 +130,7 @@ class DirectoryBasedDataFinder(
        val classFinder: DirectoryBasedClassFinder,
        val log: Logger
 ) : ClassDataFinder {
-    override fun findClassData(classId: ClassId): ClassDataWithSource? {
+    override fun findClassData(classId: ClassId): ClassData? {
        val binaryClass = classFinder.findKotlinClass(classId) ?: return null
        val classHeader = binaryClass.classHeader
        val data = classHeader.data
@@ -148,6 +144,7 @@ class DirectoryBasedDataFinder(
            return null
        }

-        return ClassDataWithSource(JvmProtoBufUtil.readClassDataFrom(data, strings), KotlinJvmBinarySourceElement(binaryClass))
+        val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(data, strings)
+        return ClassData(nameResolver, classProto, KotlinJvmBinarySourceElement(binaryClass))
    }
 }
@@ -242,22 +242,21 @@ private class ClassClsStubBuilder(
    }

    private fun createNestedClassStub(classBody: StubElement<out PsiElement>, nestedClassId: ClassId) {
-        val classDataWithSource = c.components.classDataFinder.findClassData(nestedClassId)
-        if (classDataWithSource == null) {
-            val rootFile = c.components.virtualFileForDebug
-            LOG.error(
-                    "Could not find class data for nested class $nestedClassId of class ${nestedClassId.outerClassId}\n" +
-                    "Root file: ${rootFile.canonicalPath}\n" +
-                    "Dir: ${rootFile.parent.canonicalPath}\n" +
-                    "Children:\n" +
-                    rootFile.parent.children.sortedBy { it.name }.joinToString(separator = "\n") {
-                        "${it.name} (valid: ${it.isValid})"
-                    }
-            )
-            return
-        }
-        val (nameResolver, classProto) = classDataWithSource.classData
-        createClassStub(classBody, classProto, nameResolver, nestedClassId, classDataWithSource.sourceElement, c)
+        val (nameResolver, classProto, sourceElement) =
+                c.components.classDataFinder.findClassData(nestedClassId)
+                        ?: c.components.virtualFileForDebug.let { rootFile ->
+                            LOG.error(
+                                "Could not find class data for nested class $nestedClassId of class ${nestedClassId.outerClassId}\n" +
+                                        "Root file: ${rootFile.canonicalPath}\n" +
+                                        "Dir: ${rootFile.parent.canonicalPath}\n" +
+                                        "Children:\n" +
+                                        rootFile.parent.children.sortedBy { it.name }.joinToString(separator = "\n") {
+                                            "${it.name} (valid: ${it.isValid})"
+                                        }
+                            )
+                            return
+                        }
+        createClassStub(classBody, classProto, nameResolver, nestedClassId, sourceElement, c)
    }

    companion object {