Test built-ins serializer, untie built-ins from class loader resources

compiler/builtins-serializer/src/BuiltInsSerializer.kt

@@ -17,20 +17,16 @@
 package org.jetbrains.jet.utils.builtinsSerializer
 
 import java.io.File
-import java.io.PrintStream
 import com.intellij.openapi.util.Disposer
 import org.jetbrains.jet.config.CompilerConfiguration
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment
-import org.jetbrains.jet.descriptors.serialization.DescriptorSerializer
-import org.jetbrains.jet.descriptors.serialization.SerializerExtension
+import org.jetbrains.jet.descriptors.serialization.*
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 import java.util.ArrayList
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.descriptors.serialization.ProtoBuf
 import java.io.ByteArrayOutputStream
 import java.io.DataOutputStream
 import org.jetbrains.jet.lang.types.lang.BuiltInsSerializationUtil
-import org.jetbrains.jet.descriptors.serialization.NameSerializationUtil
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import com.intellij.openapi.Disposable
 import org.jetbrains.jet.cli.common.CLIConfigurationKeys
@@ -48,24 +44,26 @@ import org.jetbrains.jet.analyzer.ModuleContent
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
-public class BuiltInsSerializer(val out: PrintStream?) {
+public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
     private var totalSize = 0
     private var totalFiles = 0
 
-    public fun serialize(destDir: File, srcDirs: Collection<File>) {
+    public fun serialize(destDir: File, srcDirs: Collection<File>, onComplete: (totalSize: Int, totalFiles: Int) -> Unit) {
         val rootDisposable = Disposer.newDisposable()
         try {
             serialize(rootDisposable, destDir, srcDirs)
+            onComplete(totalSize, totalFiles)
         }
         finally {
             Disposer.dispose(rootDisposable)
         }
     }
 
-    private class BuiltinsSourcesModule : ModuleInfo {
-        override val name: Name = Name.special("<module for resolving builtin source files>")
+    private inner class BuiltinsSourcesModule : ModuleInfo {
+        override val name = Name.special("<module for resolving builtin source files>")
         override fun dependencies() = listOf(this)
-        override fun dependencyOnBuiltins(): ModuleInfo.DependencyOnBuiltins = ModuleInfo.DependenciesOnBuiltins.NONE
+        override fun dependencyOnBuiltins(): ModuleInfo.DependencyOnBuiltins =
+                if (dependOnOldBuiltIns) ModuleInfo.DependenciesOnBuiltins.LAST else ModuleInfo.DependenciesOnBuiltins.NONE
     }
 
     fun serialize(disposable: Disposable, destDir: File, srcDirs: Collection<File>) {
@@ -100,8 +98,6 @@ public class BuiltInsSerializer(val out: PrintStream?) {
             fqName ->
             serializePackage(moduleDescriptor, fqName, destDir)
         }
-
-        out?.println("Total bytes written: $totalSize to $totalFiles files")
     }
 
     fun serializePackage(module: ModuleDescriptor, fqName: FqName, destDir: File) {

compiler/builtins-serializer/src/run.kt

@@ -42,5 +42,7 @@ found top-level declarations to <destination dir> (files such as
     val missing = srcDirs filterNot { it.exists() }
     assert(missing.isEmpty()) { "These source directories are missing: $missing" }
 
-    BuiltInsSerializer(System.out).serialize(destDir, srcDirs)
+    BuiltInsSerializer(dependOnOldBuiltIns = false).serialize(destDir, srcDirs) { (totalSize, totalFiles) ->
+        println("Total bytes written: $totalSize to $totalFiles files")
+    }
 }

compiler/testData/serialization/simple.kt

@@ -0,0 +1,11 @@
+package test
+
+class Class {
+    fun member() = null
+}
+
+fun function(int: Int, string: String = "default"): Class
+
+fun <T> T.extension(): T?
+
+val property: Unit

compiler/testData/serialization/simple.txt

@@ -0,0 +1,10 @@
+package test
+
+internal val property: kotlin.Unit
+internal fun function(/*0*/ int: kotlin.Int, /*1*/ string: kotlin.String = ...): test.Class
+internal fun </*0*/ T> T.extension(): T?
+
+internal final class Class {
+    public constructor Class()
+    internal final fun member(): kotlin.Nothing?
+}

compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltInsSerializerTest.kt

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2014 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.jet.descriptors.serialization
+
+import java.io.File
+import org.jetbrains.jet.utils.builtinsSerializer.BuiltInsSerializer
+import org.jetbrains.jet.test.TestCaseWithTmpdir
+import org.jetbrains.jet.lang.types.lang.BuiltinsPackageFragment
+import org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME
+import org.jetbrains.jet.storage.LockBasedStorageManager
+import org.jetbrains.jet.JetTestUtils
+import java.io.FileInputStream
+import org.jetbrains.jet.test.util.RecursiveDescriptorComparator
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
+
+public class BuiltInsSerializerTest : TestCaseWithTmpdir() {
+    private fun doTest(fileName: String) {
+        val source = "compiler/testData/serialization/$fileName"
+        BuiltInsSerializer(dependOnOldBuiltIns = true).serialize(
+                tmpdir,
+                listOf(File(source)),
+                { totalSize, totalFiles -> }
+        )
+
+        val module = JetTestUtils.createEmptyModule("<module>")
+
+        val packageFragment = BuiltinsPackageFragment(TEST_PACKAGE_FQNAME, LockBasedStorageManager(), module) {
+            path -> FileInputStream(File(tmpdir, path))
+        }
+
+        module.initialize(packageFragment.provider)
+        module.addDependencyOnModule(module)
+        module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
+        module.seal()
+
+        RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile(
+                module.getPackage(TEST_PACKAGE_FQNAME),
+                RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT,
+                File(source.replace(".kt", ".txt"))
+        )
+    }
+
+    fun testSimple() {
+        doTest("simple.kt")
+    }
+}

core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.kt

@@ -23,16 +23,19 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProviderImpl
 import org.jetbrains.jet.lang.descriptors.impl.PackageFragmentDescriptorImpl
-import org.jetbrains.jet.lang.resolve.name.ClassId
-import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.name.*
 import org.jetbrains.jet.storage.StorageManager
 import java.io.DataInputStream
 import java.io.InputStream
 import java.util.ArrayList
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationComponents
 
-class BuiltinsPackageFragment(storageManager: StorageManager, module: ModuleDescriptor)
-  : PackageFragmentDescriptorImpl(module, KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) {
+public class BuiltinsPackageFragment(
+        fqName: FqName,
+        storageManager: StorageManager,
+        module: ModuleDescriptor,
+        private val loadResource: (path: String) -> InputStream?
+) : PackageFragmentDescriptorImpl(module, fqName) {
 
     private val nameResolver = NameSerializationUtil.deserializeNameResolver(getStream(BuiltInsSerializationUtil.getNameTableFilePath(fqName)))
 
@@ -69,14 +72,13 @@ class BuiltinsPackageFragment(storageManager: StorageManager, module: ModuleDesc
 
     override fun getMemberScope() = members
 
-    private fun getStream(path: String) = getStreamNullable(path) ?: throw IllegalStateException("Resource not found in classpath: $path")
-
-    private fun getStreamNullable(path: String): InputStream? = javaClass<KotlinBuiltIns>().getClassLoader().getResourceAsStream(path)
+    private fun getStream(path: String): InputStream =
+            loadResource(path) ?: throw IllegalStateException("Resource not found in classpath: $path")
 
     private inner class BuiltInsClassDataFinder : ClassDataFinder {
         override fun findClassData(classId: ClassId): ClassData? {
             val metadataPath = BuiltInsSerializationUtil.getClassMetadataPath(classId) ?: return null
-            val stream = getStreamNullable(metadataPath) ?: return null
+            val stream = loadResource(metadataPath) ?: return null
 
             val classProto = ProtoBuf.Class.parseFrom(stream)
 

core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.types.lang;
 
+import kotlin.Function1;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -34,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
 
+import java.io.InputStream;
 import java.util.*;
 
 import static org.jetbrains.jet.lang.types.lang.PrimitiveType.*;
@@ -104,10 +106,18 @@ public class KotlinBuiltIns {
     private final FqNames fqNames = new FqNames();
 
     private KotlinBuiltIns() {
-        builtInsModule = new ModuleDescriptorImpl(Name.special("<built-ins lazy module>"),
-                                                  Collections.<ImportPath>emptyList(),
-                                                  PlatformToKotlinClassMap.EMPTY);
-        builtinsPackageFragment = new BuiltinsPackageFragment(new LockBasedStorageManager(), builtInsModule);
+        builtInsModule = new ModuleDescriptorImpl(
+                Name.special("<built-ins lazy module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
+        );
+        builtinsPackageFragment = new BuiltinsPackageFragment(
+                BUILT_INS_PACKAGE_FQ_NAME, new LockBasedStorageManager(), builtInsModule,
+                new Function1<String, InputStream>() {
+                    @Override
+                    public InputStream invoke(String path) {
+                        return KotlinBuiltIns.class.getClassLoader().getResourceAsStream(path);
+                    }
+                }
+        );
         builtInsModule.initialize(builtinsPackageFragment.getProvider());
         builtInsModule.addDependencyOnModule(builtInsModule);
         builtInsModule.seal();