JS: merge LibrarySourcesConfig into JsConfig

compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -50,7 +50,6 @@ import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult;
 import org.jetbrains.kotlin.js.config.EcmaVersion;
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys;
 import org.jetbrains.kotlin.js.config.JsConfig;
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.facade.K2JSTranslator;
 import org.jetbrains.kotlin.js.facade.MainCallParameters;
 import org.jetbrains.kotlin.js.facade.TranslationResult;
@@ -137,7 +136,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
 
         configuration.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile));
 
-        JsConfig config = new LibrarySourcesConfig(project, configuration);
+        JsConfig config = new JsConfig(project, configuration);
         if (config.checkLibFilesAndReportErrors(new JsConfig.Reporter() {
             @Override
             public void error(@NotNull String message) {

compiler/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJsStdLib.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig
 import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.js.resolve.MODULE_KIND
 import org.jetbrains.kotlin.name.Name
@@ -45,9 +44,9 @@ abstract class AbstractDiagnosticsTestWithJsStdLib : AbstractDiagnosticsTest() {
 
     override fun setUp() {
         super.setUp()
-        config = LibrarySourcesConfig(project, environment.configuration.copy().apply {
+        config = JsConfig(project, environment.configuration.copy().apply {
             put(CommonConfigurationKeys.MODULE_NAME, KotlinTestUtils.TEST_MODULE_NAME)
-            put(JSConfigurationKeys.LIBRARIES, LibrarySourcesConfig.JS_STDLIB)
+            put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB)
         })
     }
 

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.config.addKotlinSourceRoots
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig
+import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
@@ -50,7 +50,7 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
 
         val configuration = KotlinTestUtils.newConfiguration()
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
-        configuration.put(JSConfigurationKeys.LIBRARIES, LibrarySourcesConfig.JS_STDLIB)
+        configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB)
 
         configuration.addKotlinSourceRoots(srcDirs.map { it.path })
 
@@ -69,7 +69,7 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
         try {
             val environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
             val files = environment.getSourceFiles()
-            val config = LibrarySourcesConfig(environment.project, environment.configuration)
+            val config = JsConfig(environment.project, environment.configuration)
             val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, config)
             val description = JsModuleDescriptor(
                     name = KotlinTestUtils.TEST_MODULE_NAME,

idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys;
 import org.jetbrains.kotlin.js.config.JsConfig;
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
@@ -64,7 +63,7 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic
     private JsConfig getConfig(@Nullable LanguageVersion explicitLanguageVersion) {
         CompilerConfiguration configuration = getEnvironment().getConfiguration().copy();
         configuration.put(CommonConfigurationKeys.MODULE_NAME, KotlinTestUtils.TEST_MODULE_NAME);
-        configuration.put(JSConfigurationKeys.LIBRARIES, LibrarySourcesConfig.JS_STDLIB);
+        configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB);
         configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
         configuration.put(JSConfigurationKeys.UNIT_TEST_CONFIG, true);
         if (explicitLanguageVersion != null) {
@@ -73,6 +72,6 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic
                     new LanguageVersionSettingsImpl(explicitLanguageVersion, LanguageVersionSettingsImpl.DEFAULT.getApiVersion())
             );
         }
-        return new LibrarySourcesConfig(getProject(), configuration);
+        return new JsConfig(getProject(), configuration);
     }
 }

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

@@ -17,8 +17,16 @@
 package org.jetbrains.kotlin.js.config;
 
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.StandardFileSystems;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.util.PathUtil;
 import com.intellij.util.SmartList;
+import com.intellij.util.io.URLUtil;
+import kotlin.Unit;
 import kotlin.collections.CollectionsKt;
+import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.config.*;
@@ -33,28 +41,35 @@ import org.jetbrains.kotlin.serialization.js.ModuleKind;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.utils.JsMetadataVersion;
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata;
+import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils;
 
-import java.util.ArrayList;
+import java.io.File;
-import java.util.Collections;
+import java.util.*;
-import java.util.List;
+
+import static org.jetbrains.kotlin.config.CommonConfigurationKeysKt.getLanguageVersionSettings;
+import static org.jetbrains.kotlin.utils.PathUtil.getKotlinPathsForDistDirectory;
+
+public class JsConfig {
+    public static final List<String> JS_STDLIB =
+            Collections.singletonList(getKotlinPathsForDistDirectory().getJsStdLibJarPath().getAbsolutePath());
+
+    public static final List<String> JS_KOTLIN_TEST =
+            Collections.singletonList(getKotlinPathsForDistDirectory().getJsKotlinTestJarPath().getAbsolutePath());
+
+    public static final String UNKNOWN_EXTERNAL_MODULE_NAME = "<unknown>";
 
-/**
- * Base class representing a configuration of translator.
- */
-public abstract class JsConfig {
     private final Project project;
     private final CompilerConfiguration configuration;
     private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
 
-    @NotNull
+    private final List<KotlinJavascriptMetadata> metadata = new SmartList<KotlinJavascriptMetadata>();
-    protected final List<KotlinJavascriptMetadata> metadata = new SmartList<KotlinJavascriptMetadata>();
 
     @Nullable
     private List<JsModuleDescriptor<ModuleDescriptorImpl>> moduleDescriptors = null;
 
     private boolean initialized = false;
 
-    protected JsConfig(@NotNull Project project, @NotNull CompilerConfiguration configuration) {
+    public JsConfig(@NotNull Project project, @NotNull CompilerConfiguration configuration) {
         this.project = project;
         this.configuration = configuration;
     }
@@ -79,14 +94,81 @@ public abstract class JsConfig {
         return configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN);
     }
 
+    @NotNull
+    public List<String> getLibraries() {
+        return getConfiguration().getList(JSConfigurationKeys.LIBRARIES);
+    }
+
     public static abstract class Reporter {
         public void error(@NotNull String message) { /*Do nothing*/ }
+
         public void warning(@NotNull String message) { /*Do nothing*/ }
     }
 
-    public abstract boolean checkLibFilesAndReportErrors(@NotNull Reporter report);
+    public boolean checkLibFilesAndReportErrors(@NotNull JsConfig.Reporter report) {
+        return checkLibFilesAndReportErrors(report, null);
+    }
 
-    protected abstract void init(@NotNull List<KotlinJavascriptMetadata> metadata);
+    private boolean checkLibFilesAndReportErrors(@NotNull JsConfig.Reporter report, @Nullable Function1<VirtualFile, Unit> action) {
+        List<String> libraries = getLibraries();
+        if (libraries.isEmpty()) {
+            return false;
+        }
+
+        VirtualFileSystem fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
+        VirtualFileSystem jarFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JAR_PROTOCOL);
+
+        Set<String> modules = new HashSet<String>();
+
+        boolean skipMetadataVersionCheck =
+                getLanguageVersionSettings(configuration).isFlagEnabled(AnalysisFlags.getSkipMetadataVersionCheck());
+
+        for (String path : libraries) {
+            VirtualFile file;
+
+            File filePath = new File(path);
+            if (!filePath.exists()) {
+                report.error("Path '" + path + "' does not exist");
+                return true;
+            }
+
+            if (path.endsWith(".jar") || path.endsWith(".zip")) {
+                file = jarFileSystem.findFileByPath(path + URLUtil.JAR_SEPARATOR);
+            }
+            else {
+                file = fileSystem.findFileByPath(path);
+            }
+
+            if (file == null) {
+                report.error("File '" + path + "' does not exist or could not be read");
+                return true;
+            }
+
+            List<KotlinJavascriptMetadata> metadataList = KotlinJavascriptMetadataUtils.loadMetadata(filePath);
+            if (metadataList.isEmpty()) {
+                report.warning("'" + path + "' is not a valid Kotlin Javascript library");
+                continue;
+            }
+
+            for (KotlinJavascriptMetadata metadata : metadataList) {
+                if (!metadata.getVersion().isCompatible() && !skipMetadataVersionCheck) {
+                    report.error("File '" + path + "' was compiled with an incompatible version of Kotlin. " +
+                                 "The binary version of its metadata is " + metadata.getVersion() +
+                                 ", expected version is " + JsMetadataVersion.INSTANCE);
+                    return true;
+                }
+                if (!modules.add(metadata.getModuleName())) {
+                    report.warning("Module \"" + metadata.getModuleName() + "\" is defined in more than one file");
+                }
+            }
+
+            if (action != null) {
+                action.invoke(file);
+            }
+        }
+
+        return false;
+    }
 
     @NotNull
     public List<JsModuleDescriptor<ModuleDescriptorImpl>> getModuleDescriptors() {
@@ -114,7 +196,27 @@ public abstract class JsConfig {
     private void init() {
         if (initialized) return;
 
-        init(metadata);
+        if (!getLibraries().isEmpty()) {
+            Function1<VirtualFile, Unit> action = new Function1<VirtualFile, Unit>() {
+                @Override
+                public Unit invoke(VirtualFile file) {
+                    String libraryPath = PathUtil.getLocalPath(file);
+                    assert libraryPath != null : "libraryPath for " + file + " should not be null";
+                    metadata.addAll(KotlinJavascriptMetadataUtils.loadMetadata(libraryPath));
+
+                    return Unit.INSTANCE;
+                }
+            };
+
+            boolean hasErrors = checkLibFilesAndReportErrors(new Reporter() {
+                @Override
+                public void error(@NotNull String message) {
+                    throw new IllegalStateException(message);
+                }
+            }, action);
+            assert !hasErrors : "hasErrors should be false";
+        }
+
         initialized = true;
     }
 

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

@@ -1,154 +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.js.config;
-
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vfs.StandardFileSystems;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
-import com.intellij.openapi.vfs.VirtualFileSystem;
-import com.intellij.util.PathUtil;
-import com.intellij.util.io.URLUtil;
-import kotlin.Unit;
-import kotlin.jvm.functions.Function1;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.config.AnalysisFlags;
-import org.jetbrains.kotlin.config.CompilerConfiguration;
-import org.jetbrains.kotlin.utils.JsMetadataVersion;
-import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata;
-import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils;
-
-import java.io.File;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.jetbrains.kotlin.config.CommonConfigurationKeysKt.getLanguageVersionSettings;
-import static org.jetbrains.kotlin.utils.PathUtil.getKotlinPathsForDistDirectory;
-
-public class LibrarySourcesConfig extends JsConfig {
-    public static final List<String> JS_STDLIB =
-            Collections.singletonList(getKotlinPathsForDistDirectory().getJsStdLibJarPath().getAbsolutePath());
-
-    public static final List<String> JS_KOTLIN_TEST =
-            Collections.singletonList(getKotlinPathsForDistDirectory().getJsKotlinTestJarPath().getAbsolutePath());
-
-    public static final String UNKNOWN_EXTERNAL_MODULE_NAME = "<unknown>";
-
-    public LibrarySourcesConfig(@NotNull Project project, @NotNull CompilerConfiguration configuration) {
-        super(project, configuration);
-    }
-
-    @NotNull
-    public List<String> getLibraries() {
-        return getConfiguration().getList(JSConfigurationKeys.LIBRARIES);
-    }
-
-    @Override
-    protected void init(@NotNull final List<KotlinJavascriptMetadata> metadata) {
-        if (getLibraries().isEmpty()) return;
-
-        JsConfig.Reporter report = new JsConfig.Reporter() {
-            @Override
-            public void error(@NotNull String message) {
-                throw new IllegalStateException(message);
-            }
-        };
-
-        Function1<VirtualFile, Unit> action = new Function1<VirtualFile, Unit>() {
-            @Override
-            public Unit invoke(VirtualFile file) {
-                String libraryPath = PathUtil.getLocalPath(file);
-                assert libraryPath != null : "libraryPath for " + file + " should not be null";
-                metadata.addAll(KotlinJavascriptMetadataUtils.loadMetadata(libraryPath));
-
-                return Unit.INSTANCE;
-            }
-        };
-
-        boolean hasErrors = checkLibFilesAndReportErrors(report, action);
-        assert !hasErrors : "hasErrors should be false";
-    }
-
-    @Override
-    public boolean checkLibFilesAndReportErrors(@NotNull JsConfig.Reporter report) {
-        return checkLibFilesAndReportErrors(report, null);
-    }
-
-    private boolean checkLibFilesAndReportErrors(@NotNull JsConfig.Reporter report, @Nullable Function1<VirtualFile, Unit> action) {
-        List<String> libraries = getLibraries();
-        if (libraries.isEmpty()) {
-            return false;
-        }
-
-        VirtualFileSystem fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
-        VirtualFileSystem jarFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JAR_PROTOCOL);
-
-        Set<String> modules = new HashSet<String>();
-
-        boolean skipMetadataVersionCheck =
-                getLanguageVersionSettings(getConfiguration()).isFlagEnabled(AnalysisFlags.getSkipMetadataVersionCheck());
-
-        for (String path : libraries) {
-            VirtualFile file;
-
-            File filePath = new File(path);
-            if (!filePath.exists()) {
-                report.error("Path '" + path + "' does not exist");
-                return true;
-            }
-
-            if (path.endsWith(".jar") || path.endsWith(".zip")) {
-                file = jarFileSystem.findFileByPath(path + URLUtil.JAR_SEPARATOR);
-            }
-            else {
-                file = fileSystem.findFileByPath(path);
-            }
-
-            if (file == null) {
-                report.error("File '" + path + "' does not exist or could not be read");
-                return true;
-            }
-
-            List<KotlinJavascriptMetadata> metadataList = KotlinJavascriptMetadataUtils.loadMetadata(filePath);
-            if (metadataList.isEmpty()) {
-                report.warning("'" + path + "' is not a valid Kotlin Javascript library");
-                continue;
-            }
-
-            for (KotlinJavascriptMetadata metadata : metadataList) {
-                if (!metadata.getVersion().isCompatible() && !skipMetadataVersionCheck) {
-                    report.error("File '" + path + "' was compiled with an incompatible version of Kotlin. " +
-                                 "The binary version of its metadata is " + metadata.getVersion() +
-                                 ", expected version is " + JsMetadataVersion.INSTANCE);
-                    return true;
-                }
-                if (!modules.add(metadata.getModuleName())) {
-                    report.warning("Module \"" + metadata.getModuleName() + "\" is defined in more than one file");
-                }
-            }
-
-            if (action != null) {
-                action.invoke(file);
-            }
-        }
-
-        return false;
-    }
-}

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

@@ -23,7 +23,6 @@ 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.LibrarySourcesConfig
 import org.jetbrains.kotlin.js.inline.util.IdentitySet
 import org.jetbrains.kotlin.js.inline.util.isCallInvocation
 import org.jetbrains.kotlin.js.parser.parseFunction
@@ -65,8 +64,7 @@ class FunctionReader(private val context: TranslationContext) {
     private val moduleNameToInfo = HashMultimap.create<String, ModuleInfo>()
 
     init {
-        val config = context.config as LibrarySourcesConfig
+        val libs = context.config.libraries.map(::File)
-        val libs = config.libraries.map(::File)
 
         JsLibraryUtils.traverseJsLibraries(libs) { fileContent, _ ->
             var current = 0

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

@@ -34,7 +34,6 @@ import org.jetbrains.kotlin.js.backend.ast.JsProgram
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig
 import org.jetbrains.kotlin.js.facade.K2JSTranslator
 import org.jetbrains.kotlin.js.facade.MainCallParameters
 import org.jetbrains.kotlin.js.facade.TranslationResult
@@ -260,7 +259,7 @@ abstract class BasicBoxTest(
                     LanguageVersionSettingsImpl(languageVersion, LanguageVersionSettingsImpl.DEFAULT.apiVersion)
         }
 
-        configuration.put(JSConfigurationKeys.LIBRARIES, LibrarySourcesConfig.JS_STDLIB + LibrarySourcesConfig.JS_KOTLIN_TEST + dependencies)
+        configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB + JsConfig.JS_KOTLIN_TEST + dependencies)
 
         configuration.put(CommonConfigurationKeys.MODULE_NAME, module.name.removeSuffix(OLD_MODULE_SUFFIX))
         configuration.put(JSConfigurationKeys.MODULE_KIND, module.moduleKind)
@@ -269,7 +268,7 @@ abstract class BasicBoxTest(
         //configuration.put(JSConfigurationKeys.SOURCE_MAP, shouldGenerateSourceMap())
         configuration.put(JSConfigurationKeys.META_INFO, multiModule)
 
-        return LibrarySourcesConfig(project, configuration)
+        return JsConfig(project, configuration)
     }
 
     private inner class TestFileFactoryImpl : TestFileFactory<TestModule, TestFile>, Closeable {

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.js.test;
 
 import com.google.common.collect.Lists;
-import org.jetbrains.kotlin.js.backend.ast.JsProgram;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.StandardFileSystems;
@@ -39,10 +38,10 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.js.JavaScript;
+import org.jetbrains.kotlin.js.backend.ast.JsProgram;
 import org.jetbrains.kotlin.js.config.EcmaVersion;
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys;
 import org.jetbrains.kotlin.js.config.JsConfig;
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.facade.K2JSTranslator;
 import org.jetbrains.kotlin.js.facade.MainCallParameters;
 import org.jetbrains.kotlin.js.facade.TranslationResult;
@@ -316,7 +315,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
 
         configuration.put(CommonConfigurationKeys.DISABLE_INLINE, hasNoInline(files));
 
-        List<String> librariesWithStdlib = new ArrayList<String>(LibrarySourcesConfig.JS_STDLIB);
+        List<String> librariesWithStdlib = new ArrayList<String>(JsConfig.JS_STDLIB);
         if (libraries != null) {
             librariesWithStdlib.addAll(libraries);
         }
@@ -332,7 +331,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
 
         configuration.put(JSConfigurationKeys.UNIT_TEST_CONFIG, shouldBeTranslateAsUnitTestClass());
 
-        return new LibrarySourcesConfig(project, configuration);
+        return new JsConfig(project, configuration);
     }
 
     private static boolean hasNoInline(@NotNull List<KtFile> files) {

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

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.config.LibrarySourcesConfig
+import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.naming.encodeSignature
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
@@ -207,10 +207,10 @@ class EncodeSignatureTest {
             val psiFile = psiManager.findFile(file) as KtFile
 
             val configuration = environment.configuration.copy()
-            configuration.put(JSConfigurationKeys.LIBRARIES, LibrarySourcesConfig.JS_STDLIB)
+            configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB)
             configuration.put(CommonConfigurationKeys.MODULE_NAME, "sample")
 
-            val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(listOf(psiFile), LibrarySourcesConfig(project, configuration))
+            val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(listOf(psiFile), JsConfig(project, configuration))
             val module = analysisResult.moduleDescriptor
             val rootPackage = module.getPackage(FqName.ROOT)
 
@@ -248,4 +248,4 @@ class EncodeSignatureTest {
     fun createEnvironment(disposable: Disposable): KotlinCoreEnvironment {
         return KotlinCoreEnvironment.createForTests(disposable, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES)
     }
-}
+}

js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java

@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.js.config.LibrarySourcesConfig.UNKNOWN_EXTERNAL_MODULE_NAME;
+import static org.jetbrains.kotlin.js.config.JsConfig.UNKNOWN_EXTERNAL_MODULE_NAME;
 import static org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils.isLibraryObject;
 import static org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils.isNativeObject;
 import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.pureFqn;