JS: minor fixes after rebasing

Multiple minor fixes after rebasing incremental compilation related
branch to actual master

js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.configureModule
@@ -34,13 +33,14 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
+import org.jetbrains.kotlin.serialization.js.PackagesWithHeaderMetadata
 
 fun createTopDownAnalyzerForJs(
         moduleContext: ModuleContext,
         bindingTrace: BindingTrace,
         declarationProviderFactory: DeclarationProviderFactory,
         languageVersionSettings: LanguageVersionSettings,
-        fallbackMetadata: List<ByteArray> = emptyList()
+        fallbackMetadata: PackagesWithHeaderMetadata? = null
 ): LazyTopDownAnalyzer {
     val storageComponentContainer = createContainer("TopDownAnalyzerForJs", JsPlatform) {
         configureModule(moduleContext, JsPlatform, TargetPlatformVersion.NoVersion, bindingTrace)
@@ -55,10 +55,10 @@ fun createTopDownAnalyzerForJs(
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzer>()
     }.apply {
-        val packagePartProviders = mutableListOf<PackageFragmentProvider>(get<KotlinCodeAnalyzer>().packageFragmentProvider)
+        val packagePartProviders = mutableListOf(get<KotlinCodeAnalyzer>().packageFragmentProvider)
         val moduleDescriptor = get<ModuleDescriptorImpl>()
-        if (fallbackMetadata.isNotEmpty()) {
+        if (fallbackMetadata != null) {
-            packagePartProviders += KotlinJavascriptSerializationUtil.readScope(
+            packagePartProviders += KotlinJavascriptSerializationUtil.readDescriptors(
                     fallbackMetadata, moduleContext.storageManager, moduleDescriptor, DeserializationConfiguration.Default)
         }
         moduleDescriptor.initialize(CompositePackageFragmentProvider(packagePartProviders))

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -58,7 +58,7 @@ object TopDownAnalyzerFacadeForJS {
                 moduleContext, trace,
                 FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
                 config.configuration.languageVersionSettings,
-                config.configuration[JSConfigurationKeys.FALLBACK_METADATA].orEmpty()
+                config.configuration[JSConfigurationKeys.FALLBACK_METADATA]
         )
         analyzerForJs.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
         return JsAnalysisResult.success(trace, moduleContext.module)

js/js.frontend/src/org/jetbrains/kotlin/js/config/JSConfigurationKeys.java

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.js.config;
 
 import org.jetbrains.kotlin.config.CompilerConfigurationKey;
 import org.jetbrains.kotlin.serialization.js.ModuleKind;
+import org.jetbrains.kotlin.serialization.js.PackagesWithHeaderMetadata;
 
 import java.util.List;
 
@@ -40,7 +41,7 @@ public class JSConfigurationKeys {
     public static final CompilerConfigurationKey<Boolean> TYPED_ARRAYS_ENABLED =
             CompilerConfigurationKey.create("TypedArrays enabled");
 
-    public static final CompilerConfigurationKey<List<byte[]>> FALLBACK_METADATA =
+    public static final CompilerConfigurationKey<PackagesWithHeaderMetadata> FALLBACK_METADATA =
             CompilerConfigurationKey.create("fallback metadata");
 
     public static final CompilerConfigurationKey<Boolean> SERIALIZE_FRAGMENTS = CompilerConfigurationKey.create("serialize fragments");

js/js.inliner/src/org/jetbrains/kotlin/js/coroutine/CoroutinePasses.kt

@@ -249,10 +249,10 @@ fun JsBlock.replaceLocalVariables(context: CoroutineTransformationContext, local
                 val wrapperFunction = JsFunction(x.scope.parent, JsBlock(), "")
                 val wrapperInvocation = JsInvocation(wrapperFunction)
                 wrapperFunction.body.statements += JsReturn(x)
-                val nameMap = freeVars.associate { it to wrapperFunction.scope.declareTemporaryName(it.ident) }
+                val nameMap = freeVars.associate { it to JsScope.declareTemporaryName(it.ident) }
                 for (freeVar in freeVars) {
                     wrapperFunction.parameters += JsParameter(nameMap[freeVar]!!)
-                    wrapperInvocation.arguments += JsNameRef(scope.getFieldName(freeVar), JsLiteral.THIS)
+                    wrapperInvocation.arguments += JsNameRef(context.getFieldName(freeVar), JsLiteral.THIS)
                 }
                 x.body = replaceNames(x.body, nameMap.mapValues { it.value.makeRef() })
                 ctx.replaceMe(wrapperInvocation)

js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.builtins.isFunctionTypeOrSubtype
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.js.backend.ast.*
 import org.jetbrains.kotlin.js.backend.ast.metadata.inlineStrategy
+import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.inline.util.IdentitySet
 import org.jetbrains.kotlin.js.inline.util.isCallInvocation
 import org.jetbrains.kotlin.js.parser.parseFunction
@@ -46,7 +47,7 @@ private val JS_IDENTIFIER="[$JS_IDENTIFIER_START][$JS_IDENTIFIER_PART]*"
 private val DEFINE_MODULE_PATTERN = ("($JS_IDENTIFIER)\\.defineModule\\(\\s*(['\"])([^'\"]+)\\2\\s*,\\s*(\\w+)\\s*\\)").toRegex().toPattern()
 private val DEFINE_MODULE_FIND_PATTERN = ".defineModule("
 
-class FunctionReader(private val config: LibrarySourcesConfig, private val currentModuleName: JsName, fragments: List<JsProgramFragment>) {
+class FunctionReader(private val config: JsConfig, private val currentModuleName: JsName, fragments: List<JsProgramFragment>) {
     /**
      * fileContent: .js file content, that contains this module definition.
      *     One file can contain more than one module definition.

js/js.inliner/src/org/jetbrains/kotlin/js/inline/JsInliner.java

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.js.backend.ast.*;
 import org.jetbrains.kotlin.js.backend.ast.metadata.MetadataProperties;
 import org.jetbrains.kotlin.js.config.JsConfig;
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.inline.clean.FunctionPostProcessor;
 import org.jetbrains.kotlin.js.inline.clean.RemoveUnusedFunctionDefinitionsKt;
 import org.jetbrains.kotlin.js.inline.clean.RemoveUnusedLocalFunctionDeclarationsKt;
@@ -76,7 +75,7 @@ public class JsInliner extends JsVisitorWithContextImpl {
             accessorInvocationTransformer.accept(fragment.getDeclarationBlock());
             accessorInvocationTransformer.accept(fragment.getInitializerBlock());
         }
-        FunctionReader functionReader = new FunctionReader((LibrarySourcesConfig) config, currentModuleName, fragments);
+        FunctionReader functionReader = new FunctionReader(config, currentModuleName, fragments);
         JsInliner inliner = new JsInliner(functions, accessors, functionReader, trace);
         for (JsProgramFragment fragment : fragmentsToProcess) {
             inliner.inliningContexts.push(inliner.new JsInliningContext());

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.serialization.js
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.protobuf.CodedInputStream
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -51,14 +52,17 @@ object KotlinJavascriptSerializationUtil {
         ))
     }
 
-    fun readScope(
+    fun readDescriptors(
-            metadata: Collection<ByteArray>,
+            metadata: PackagesWithHeaderMetadata,
             storageManager: StorageManager,
             module: ModuleDescriptor,
             configuration: DeserializationConfiguration
     ): PackageFragmentProvider {
-        val scopeProto = metadata.map { JsProtoBuf.Library.Part.parseFrom(it, JsSerializerProtocol.extensionRegistry) }
+        val scopeProto = metadata.packages.map {
-        return createKotlinJavascriptPackageFragmentProvider(storageManager, module, scopeProto, configuration)
+            ProtoBuf.PackageFragment.parseFrom(it, JsSerializerProtocol.extensionRegistry)
+        }
+        val headerProto = JsProtoBuf.Header.parseFrom(CodedInputStream.newInstance(metadata.header), JsSerializerProtocol.extensionRegistry)
+        return createKotlinJavascriptPackageFragmentProvider(storageManager, module, headerProto, scopeProto, configuration)
     }
 
     fun serializeMetadata(
@@ -94,18 +98,18 @@ object KotlinJavascriptSerializationUtil {
     fun metadataAsString(bindingContext: BindingContext, jsDescriptor: JsModuleDescriptor<ModuleDescriptor>): String =
             KotlinJavascriptMetadataUtils.formatMetadataAsString(jsDescriptor.name, jsDescriptor.serializeToBinaryMetadata(bindingContext))
 
-    fun serializePackage(bindingContext: BindingContext, module: ModuleDescriptor, fqName: FqName): JsProtoBuf.Library.Part {
+    fun serializePackageFragment(bindingContext: BindingContext, module: ModuleDescriptor, fqName: FqName): ProtoBuf.PackageFragment {
         val packageView = module.getPackage(fqName)
-        return serializeScope(bindingContext, module, packageView.memberScope.getContributedDescriptors(), fqName)
+        return serializeDescriptors(bindingContext, module, packageView.memberScope.getContributedDescriptors(), fqName)
     }
 
-    fun serializeScope(
+    fun serializeDescriptors(
             bindingContext: BindingContext,
             module: ModuleDescriptor,
             scope: Collection<DeclarationDescriptor>,
             fqName: FqName
-    ): JsProtoBuf.Library.Part {
+    ): ProtoBuf.PackageFragment {
-        val builder = JsProtoBuf.Library.Part.newBuilder()
+        val builder = ProtoBuf.PackageFragment.newBuilder()
 
         // TODO: ModuleDescriptor should be able to return the package only with the contents of that module, without dependencies
         val skip: (DeclarationDescriptor) -> Boolean = { DescriptorUtils.getContainingModule(it) != module || (it is MemberDescriptor && it.isHeader) }
@@ -195,7 +199,7 @@ object KotlinJavascriptSerializationUtil {
         return contentMap
     }
 
-    private fun serializeHeader(packageFqName: FqName?): JsProtoBuf.Header {
+    fun serializeHeader(packageFqName: FqName?): JsProtoBuf.Header {
         val header = JsProtoBuf.Header.newBuilder()
 
         if (packageFqName != null) {

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/PackagesWithHeaderMetadata.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2017 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.js
+
+class PackagesWithHeaderMetadata(val header: ByteArray, val packages: List<ByteArray>)

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt

@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.serialization.js.ModuleKind
+import org.jetbrains.kotlin.serialization.js.PackagesWithHeaderMetadata
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils.TestFileFactory
@@ -264,10 +265,12 @@ abstract class BasicBoxTest(
                 TranslationUnit.BinaryAst(FileUtil.loadFileBytes(astFile))
             }
 
-    val recompiledConfig = createConfig(module, dependencies, multiModule, serializedMetadata)
+            val headerFile = File(incrementalDir, HEADER_FILE)
+            val recompiledConfig = createConfig(module, dependencies, multiModule, Pair(headerFile,serializedMetadata))
             val recompiledOutputFile = File(outputFile.parentFile, outputFile.nameWithoutExtension + "-recompiled.js")
 
-            translateFiles(allTranslationUnits, recompiledOutputFile, recompiledConfig)
+            translateFiles(allTranslationUnits, recompiledOutputFile, recompiledConfig, outputPrefixFile, outputPostfixFile,
+                           mainCallParameters)
 
             val originalOutput = FileUtil.loadFile(outputFile)
             val recompiledOutput = removeRecompiledSuffix(FileUtil.loadFile(recompiledOutputFile))
@@ -280,7 +283,9 @@ abstract class BasicBoxTest(
         }
     }
 
-    private fun removeRecompiledSuffix(text: String): String = text.replace("-recompiled.js", ".js")protected fun translateFiles(units: List<TranslationUnit>, outputFile: File, config: JsConfig,
+    private fun removeRecompiledSuffix(text: String): String = text.replace("-recompiled.js", ".js")
+
+    protected fun translateFiles(units: List<TranslationUnit>, outputFile: File, config: JsConfig,
             outputPrefixFile: File?,
             outputPostfixFile: File?,
             mainCallParameters: MainCallParameters) {
@@ -331,6 +336,10 @@ abstract class BasicBoxTest(
             }
         }
 
+        translationResult.metadataHeader?.let {
+            FileUtil.writeToFile(File(incrementalDir, HEADER_FILE), it)
+        }
+
         processJsProgram(translationResult.program, units.filterIsInstance<TranslationUnit.SourceFile>().map { it.file })
     }
 
@@ -351,8 +360,7 @@ abstract class BasicBoxTest(
     private fun createPsiFiles(fileNames: List<String>): List<KtFile> = fileNames.map(this::createPsiFile)
 
     private fun createConfig(
-            module: TestModule, dependencies: List<String>, multiModule: Boolean,
+            module: TestModule, dependencies: List<String>, multiModule: Boolean, additionalMetadata: Pair<File, List<File>>?
-            additionalMetadata: List<File>?
     ): JsConfig {
         val configuration = environment.configuration.copy()
 
@@ -376,7 +384,10 @@ abstract class BasicBoxTest(
         configuration.put(JSConfigurationKeys.SOURCE_MAP, hasFilesToRecompile)
 
         if (additionalMetadata != null) {
-            configuration.put(JSConfigurationKeys.FALLBACK_METADATA, additionalMetadata.map { FileUtil.loadFileBytes(it) })
+            val metadata = PackagesWithHeaderMetadata(
+                    FileUtil.loadFileBytes(additionalMetadata.first),
+                    additionalMetadata.second.map { FileUtil.loadFileBytes(it) })
+            configuration.put(JSConfigurationKeys.FALLBACK_METADATA, metadata)
         }
 
         if (typedArraysEnabled) {
@@ -472,6 +483,7 @@ abstract class BasicBoxTest(
         private val RECOMPILE_PATTERN = Pattern.compile("^// *RECOMPILE *$", Pattern.MULTILINE)
         private val AST_EXTENSION = "jsast"
         private val METADATA_EXTENSION = "jsmeta"
+        private val HEADER_FILE = "header.$METADATA_EXTENSION"
 
         private val TEST_MODULE = "JS_TESTS"
         private val DEFAULT_MODULE = "main"

js/js.tests/test/org/jetbrains/kotlin/js/test/ast/NameResolutionTest.kt

@@ -22,7 +22,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.js.backend.ast.*
 import org.jetbrains.kotlin.js.inline.clean.resolveTemporaryNames
 import org.jetbrains.kotlin.js.parser.parse
-import org.jetbrains.kotlin.js.test.BasicTest
+import org.jetbrains.kotlin.js.test.BasicBoxTest
 import org.junit.Assert.assertEquals
 import org.junit.Assert.fail
 import org.junit.Rule
@@ -49,7 +49,7 @@ class NameResolutionTest {
 
     private fun doTest() {
         val methodName = testName.methodName
-        val baseName = "${BasicTest.TEST_DATA_DIR_PATH}/js-name-resolution/"
+        val baseName = "${BasicBoxTest.TEST_DATA_DIR_PATH}/js-name-resolution/"
         val originalName = "$baseName/$methodName.original.js"
         val expectedName = "$baseName/$methodName.expected.js"
 

js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStat
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
-import org.jetbrains.kotlin.serialization.js.JsProtoBuf;
+import org.jetbrains.kotlin.serialization.ProtoBuf;
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil;
 import org.jetbrains.kotlin.serialization.js.ast.JsAstSerializer;
 
@@ -138,6 +138,7 @@ public final class K2JSTranslator {
 
         Map<KtFile, FileTranslationResult> fileMap = new HashMap<KtFile, FileTranslationResult>();
         JsAstSerializer serializer = new JsAstSerializer();
+        byte[] metadataHeader = null;
         boolean serializeFragments = config.getConfiguration().get(JSConfigurationKeys.SERIALIZE_FRAGMENTS, false);
         for (KtFile file : files) {
             List<DeclarationDescriptor> scope = translationResult.getFileMemberScopes().get(file);
@@ -152,7 +153,7 @@ public final class K2JSTranslator {
                 }
 
                 if (scope != null) {
-                    JsProtoBuf.Library.Part part = KotlinJavascriptSerializationUtil.INSTANCE.serializeScope(
+                    ProtoBuf.PackageFragment part = KotlinJavascriptSerializationUtil.INSTANCE.serializeDescriptors(
                             bindingTrace.getBindingContext(), moduleDescriptor, scope, file.getPackageFqName());
                     binaryMetadata = part.toByteArray();
                 }
@@ -161,6 +162,10 @@ public final class K2JSTranslator {
             fileMap.put(file, new FileTranslationResult(file, binaryMetadata, binaryAst));
         }
 
+        if (serializeFragments) {
+            metadataHeader = KotlinJavascriptSerializationUtil.INSTANCE.serializeHeader(null).toByteArray();
+        }
+
         ResolveTemporaryNamesKt.resolveTemporaryNames(translationResult.getProgram());
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
         if (hasError(diagnostics)) return new TranslationResult.Fail(diagnostics);
@@ -170,6 +175,6 @@ public final class K2JSTranslator {
             importedModules.add(module.getExternalName());
         }
         return new TranslationResult.Success(config, files, translationResult.getProgram(), diagnostics, importedModules,
-                                             moduleDescriptor, bindingTrace.getBindingContext(), fileMap);
+                                             moduleDescriptor, bindingTrace.getBindingContext(), metadataHeader, fileMap);
     }
 }

js/js.translator/src/org/jetbrains/kotlin/js/facade/TranslationResult.kt

@@ -49,6 +49,7 @@ abstract class TranslationResult protected constructor(val diagnostics: Diagnost
             private val importedModules: List<String>,
             private val moduleDescriptor: ModuleDescriptor,
             private val bindingContext: BindingContext,
+            val metadataHeader: ByteArray?,
             val fileTranslationResults: Map<KtFile, FileTranslationResult>
     ) : TranslationResult(diagnostics) {
         @Suppress("unused") // Used in kotlin-web-demo in WebDemoTranslatorFacade