Minor, convert ClassData and PackageData to Kotlin data classes

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

@@ -135,12 +135,12 @@ public class IncrementalPackageFragmentProvider(
         override fun getMemberScope(): JetScope = memberScope()
 
         private inner class IncrementalPackageScope(val packageData: PackageData) : DeserializedPackageMemberScope(
-                this@IncrementalPackageFragment, packageData.getPackageProto(), packageData.getNameResolver(), deserializationComponents,
+                this@IncrementalPackageFragment, packageData.packageProto, packageData.nameResolver, deserializationComponents,
                 { listOf() }
         ) {
             override fun filteredMemberProtos(allMemberProtos: Collection<ProtoBuf.Callable>): Collection<ProtoBuf.Callable> {
                 fun getPackagePart(callable: ProtoBuf.Callable) =
-                        callable.getExtension(JvmProtoBuf.implClassName)?.let { packageData.getNameResolver().getName(it) }
+                        callable.getExtension(JvmProtoBuf.implClassName)?.let { packageData.nameResolver.getName(it) }
 
                 fun shouldSkipPackagePart(name: Name) =
                         JvmClassName.byFqNameWithoutInnerClasses(fqName.child(name)).getInternalName() in obsoletePackageParts

core/deserialization/src/org/jetbrains/kotlin/serialization/PackageData.java

@@ -1,40 +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.annotations.NotNull;
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
-
-public final class PackageData {
-    private final NameResolver nameResolver;
-    private final ProtoBuf.Package packageProto;
-
-    public PackageData(@NotNull NameResolver nameResolver, @NotNull ProtoBuf.Package packageProto) {
-        this.nameResolver = nameResolver;
-        this.packageProto = packageProto;
-    }
-
-    @NotNull
-    public NameResolver getNameResolver() {
-        return nameResolver;
-    }
-
-    @NotNull
-    public ProtoBuf.Package getPackageProto() {
-        return packageProto;
-    }
-}

core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoDatas.kt

@@ -14,27 +14,16 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.serialization;
+package org.jetbrains.kotlin.serialization
 
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.serialization.deserialization.NameResolver
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
 
-public final class ClassData {
+data class ClassData(
-    private final NameResolver nameResolver;
+        val nameResolver: NameResolver,
-    private final ProtoBuf.Class classProto;
+        val classProto: ProtoBuf.Class
+)
 
-    public ClassData(@NotNull NameResolver nameResolver, @NotNull ProtoBuf.Class classProto) {
+data class PackageData(
-        this.nameResolver = nameResolver;
+        val nameResolver: NameResolver,
-        this.classProto = classProto;
+        val packageProto: ProtoBuf.Package
-    }
+)
-
-    @NotNull
-    public NameResolver getNameResolver() {
-        return nameResolver;
-    }
-
-    @NotNull
-    public ProtoBuf.Class getClassProto() {
-        return classProto;
-    }
-}

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ClassDeserializer.kt

@@ -34,7 +34,7 @@ public class ClassDeserializer(private val components: DeserializationComponents
         val classDataProvider = key.classDataProvider
                                 ?: components.classDataFinder.findClassData(classId)
                                 ?: return null
-        val classData = classDataProvider.classData
+        val (nameResolver, classProto) = classDataProvider.classData
 
         val outerContext = if (classId.isNestedClass()) {
             val outerClass = deserializeClass(classId.getOuterClassId()) as? DeserializedClassDescriptor ?: return null
@@ -54,11 +54,10 @@ public class ClassDeserializer(private val components: DeserializationComponents
                 if (!fragment.hasTopLevelClass(classId.getShortClassName())) return null
             }
 
-            components.createContext(fragment, classData.getNameResolver())
+            components.createContext(fragment, nameResolver)
         }
 
-        return DeserializedClassDescriptor(outerContext, classData.getClassProto(), classData.getNameResolver(),
+        return DeserializedClassDescriptor(outerContext, classProto, nameResolver, classDataProvider.sourceElement)
-                                           classDataProvider.sourceElement)
     }
 
     private data class ClassKey(val classId: ClassId, classDataProvider: ClassDataProvider?) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt

@@ -221,7 +221,7 @@ private class ClassClsStubBuilder(
 
     private fun createNestedClassStub(classBody: StubElement<out PsiElement>, nestedClassId: ClassId) {
         val classDataProvider = c.components.classDataFinder.findClassData(nestedClassId)!!
-        val classData = classDataProvider.classData
+        val (nameResolver, classProto) = classDataProvider.classData
-        createClassStub(classBody, classData.getClassProto(), nestedClassId, c.child(classData.getNameResolver()))
+        createClassStub(classBody, classProto, nestedClassId, c.child(nameResolver))
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt

@@ -24,7 +24,6 @@ import com.intellij.psi.stubs.PsiFileStub
 import com.intellij.util.indexing.FileContent
 import org.jetbrains.kotlin.idea.decompiler.findMultifileClassParts
 import org.jetbrains.kotlin.idea.decompiler.isKotlinInternalCompiledFile
-import org.jetbrains.kotlin.idea.decompiler.readMultifileClassPartHeaders
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.DirectoryBasedClassFinder
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.DirectoryBasedDataFinder
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.LoggingErrorReporter
@@ -73,20 +72,20 @@ public open class KotlinClsStubBuilder : ClsStubBuilder() {
         }
         return when {
             header.isCompatiblePackageFacadeKind() -> {
-                val packageData = JvmProtoBufUtil.readPackageDataFrom(annotationData)
+                val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(annotationData)
-                val context = components.createContext(packageData.getNameResolver(), packageFqName)
+                val context = components.createContext(nameResolver, packageFqName)
-                createPackageFacadeStub(packageData.getPackageProto(), packageFqName, context)
+                createPackageFacadeStub(packageProto, packageFqName, context)
             }
             header.isCompatibleClassKind() -> {
                 if (header.classKind != JvmAnnotationNames.KotlinClass.Kind.CLASS) return null
-                val classData = JvmProtoBufUtil.readClassDataFrom(annotationData)
+                val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(annotationData)
-                val context = components.createContext(classData.getNameResolver(), packageFqName)
+                val context = components.createContext(nameResolver, packageFqName)
-                createTopLevelClassStub(classId, classData.getClassProto(), context)
+                createTopLevelClassStub(classId, classProto, context)
             }
             header.isCompatibleFileFacadeKind() -> {
-                val packageData = JvmProtoBufUtil.readPackageDataFrom(annotationData)
+                val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(annotationData)
-                val context = components.createContext(packageData.getNameResolver(), packageFqName)
+                val context = components.createContext(nameResolver, packageFqName)
-                createFileFacadeStub(packageData.getPackageProto(), classId.asSingleFqName(), context)
+                createFileFacadeStub(packageProto, classId.asSingleFqName(), context)
             }
             else -> throw IllegalStateException("Should have processed " + file.getPath() + " with header $header")
         }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubBuilder.kt

@@ -39,7 +39,7 @@ public open class KotlinJavaScriptStubBuilder : ClsStubBuilder() {
     override fun getStubVersion() = ClassFileStubBuilder.STUB_VERSION + 1
 
     override fun buildFileStub(content: FileContent): PsiFileStub<*>? {
-        val file = content.getFile()
+        val file = content.file
 
         if (isKotlinJavaScriptInternalCompiledFile(file)) return null
 
@@ -55,33 +55,32 @@ public open class KotlinJavaScriptStubBuilder : ClsStubBuilder() {
         val moduleDirectory = JsMetaFileUtils.getModuleDirectory(file)
         val stringsFileName = KotlinJavascriptSerializedResourcePaths.getStringTableFilePath(packageFqName)
         val stringsFile = moduleDirectory.findFileByRelativePath(stringsFileName)
-        assert(stringsFile != null, "strings file not found: $stringsFileName")
+        assert(stringsFile != null) { "strings file not found: $stringsFileName" }
 
         val nameResolver = NameResolver.read(ByteArrayInputStream(stringsFile!!.contentsToByteArray(false)))
         val components = createStubBuilderComponents(file, packageFqName, nameResolver)
 
         if (isPackageHeader) {
             val packageData = content.toPackageData(nameResolver)
-            val context = components.createContext(packageData.getNameResolver(), packageFqName)
+            val context = components.createContext(packageData.nameResolver, packageFqName)
-            return createPackageFacadeStub(packageData.getPackageProto(), packageFqName, context)
+            return createPackageFacadeStub(packageData.packageProto, packageFqName, context)
         }
         else {
-            val classData =  content.toClassData(nameResolver)
+            val classData = content.toClassData(nameResolver)
-            val context = components.createContext(classData.getNameResolver(), packageFqName)
+            val context = components.createContext(classData.nameResolver, packageFqName)
             val classId = JsMetaFileUtils.getClassId(file)
-            return createTopLevelClassStub(classId, classData.getClassProto(), context)
+            return createTopLevelClassStub(classId, classData.classProto, context)
         }
     }
 
     private fun createStubBuilderComponents(file: VirtualFile, packageFqName: FqName, nameResolver: NameResolver): ClsStubBuilderComponents {
-        val metaFileFinder = DirectoryBasedKotlinJavaScriptMetaFileFinder(file.getParent()!!, packageFqName, nameResolver)
+        val metaFileFinder = DirectoryBasedKotlinJavaScriptMetaFileFinder(file.parent!!, packageFqName, nameResolver)
         val classDataFinder = DirectoryBasedKotlinJavaScriptDataFinder(metaFileFinder, LOG)
         val annotationLoader = AnnotationLoaderForKotlinJavaScriptStubBuilder()
         return ClsStubBuilderComponents(classDataFinder, annotationLoader)
     }
 
     companion object {
-        val LOG = Logger.getInstance(javaClass<KotlinJavaScriptStubBuilder>())
+        val LOG = Logger.getInstance(KotlinJavaScriptStubBuilder::class.java)
     }
 }
-

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompiler.kt

@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
     val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
     assert(kotlinClass != null) { "Decompiled data factory shouldn't be called on an unsupported file: " + classFile }
-    val packageFqName = kotlinClass!!.getClassId().getPackageFqName()
+    val packageFqName = kotlinClass!!.classId.packageFqName
-    return DeserializerForDecompiler(classFile.getParent()!!, packageFqName)
+    return DeserializerForDecompiler(classFile.parent!!, packageFqName)
 }
 
 public class DeserializerForDecompiler(
@@ -62,22 +62,19 @@ public class DeserializerForDecompiler(
             "Was called for $facadeFqName; only members of $directoryPackageFqName package are expected."
         }
         val binaryClassForPackageClass = classFinder.findKotlinClass(ClassId.topLevel(facadeFqName))
-        val annotationData = binaryClassForPackageClass?.getClassHeader()?.annotationData
+        val annotationData = binaryClassForPackageClass?.classHeader?.annotationData
         if (annotationData == null) {
-            LOG.error("Could not read annotation data for $facadeFqName from ${binaryClassForPackageClass?.getClassId()}")
+            LOG.error("Could not read annotation data for $facadeFqName from ${binaryClassForPackageClass?.classId}")
             return emptyList()
         }
-        val packageData = JvmProtoBufUtil.readPackageDataFrom(annotationData)
+        val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(annotationData)
         val membersScope = DeserializedPackageMemberScope(
-                createDummyPackageFragment(packageFqName),
+                createDummyPackageFragment(packageFqName), packageProto, nameResolver, deserializationComponents
-                packageData.getPackageProto(),
-                packageData.getNameResolver(),
-                deserializationComponents
         ) { emptyList() }
         return membersScope.getDescriptors()
     }
 
     companion object {
-        private val LOG = Logger.getInstance(javaClass<DeserializerForDecompiler>())
+        private val LOG = Logger.getInstance(DeserializerForDecompiler::class.java)
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDeserializerForDecompiler.kt

@@ -31,7 +31,7 @@ import java.io.ByteArrayInputStream
 
 public class KotlinJavaScriptDeserializerForDecompiler(
         classFile: VirtualFile
-) : DeserializerForDecompilerBase(classFile.getParent()!!, JsMetaFileUtils.getPackageFqName(classFile)) {
+) : DeserializerForDecompilerBase(classFile.parent!!, JsMetaFileUtils.getPackageFqName(classFile)) {
 
     private val nameResolver = run {
         val moduleDirectory = JsMetaFileUtils.getModuleDirectory(packageDirectory)
@@ -65,13 +65,10 @@ public class KotlinJavaScriptDeserializerForDecompiler(
         }
 
         val content = file.contentsToByteArray(false)
-        val packageData = content.toPackageData(nameResolver)
+        val (nameResolver, packageProto) = content.toPackageData(nameResolver)
 
         val membersScope = DeserializedPackageMemberScope(
-                createDummyPackageFragment(packageFqName),
+                createDummyPackageFragment(packageFqName), packageProto, nameResolver, deserializationComponents
-                packageData.getPackageProto(),
-                packageData.getNameResolver(),
-                deserializationComponents
         ) { emptyList() }
         return membersScope.getDescriptors()
     }