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")
+    }
+}