Drop JsConfig#inlineEnabled flag

Use CommonConfigurationKeys#DISABLE_INLINE flag (moved from
JVMConfigurationKeys) in CompilerConfiguration instead, similarly to the JVM
compiler

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.codegen.inline.InlineCache
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
 import org.jetbrains.kotlin.codegen.optimization.OptimizationClassBuilderFactory
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -149,7 +150,7 @@ class GenerationState @JvmOverloads constructor(
 
     val isCallAssertionsDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS)
     val isParamAssertionsDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS)
-    val isInlineDisabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.DISABLE_INLINE)
+    val isInlineDisabled: Boolean = configuration.getBoolean(CommonConfigurationKeys.DISABLE_INLINE)
     val useTypeTableInSerializer: Boolean = configuration.getBoolean(JVMConfigurationKeys.USE_TYPE_TABLE)
     val inheritMultifileParts: Boolean = configuration.getBoolean(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS)
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.cli.common.messages.*;
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler;
 import org.jetbrains.kotlin.cli.jvm.compiler.CompileEnvironmentException;
 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.progress.CompilationCanceledException;
@@ -233,6 +234,10 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> {
     private static void setupCommonArgumentsAndServices(
             @NotNull CompilerConfiguration configuration, @NotNull CommonCompilerArguments arguments, @NotNull Services services
     ) {
+        if (arguments.noInline) {
+            configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
+        }
+
         CompilerJarLocator locator = services.get(CompilerJarLocator.class);
         if (locator != null) {
             configuration.put(CLIConfigurationKeys.COMPILER_JAR_LOCATOR, locator);

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

@@ -255,7 +255,6 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         }
         EcmaVersion ecmaVersion = EcmaVersion.defaultVersion();
         String moduleId = FileUtil.getNameWithoutExtension(new File(arguments.outputFile));
-        boolean inlineEnabled = !arguments.noInline;
 
         List<String> libraryFiles = new SmartList<String>();
         if (!arguments.noStdlib) {
@@ -269,7 +268,6 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         return new LibrarySourcesConfig.Builder(project, configuration, moduleId, libraryFiles)
                 .ecmaVersion(ecmaVersion)
                 .sourceMap(arguments.sourceMap)
-                .inlineEnabled(inlineEnabled)
                 .metaInfo(arguments.metaInfo)
                 .kjsm(arguments.kjsm)
                 .build();

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -282,7 +282,6 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
         private fun putAdvancedOptions(configuration: CompilerConfiguration, arguments: K2JVMCompilerArguments) {
             configuration.put(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, arguments.noCallAssertions)
             configuration.put(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, arguments.noParamAssertions)
-            configuration.put(JVMConfigurationKeys.DISABLE_INLINE, arguments.noInline)
             configuration.put(JVMConfigurationKeys.DISABLE_OPTIMIZATION, arguments.noOptimize)
             configuration.put(JVMConfigurationKeys.DECLARATIONS_JSON_PATH, arguments.declarationsOutputPath)
             configuration.put(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, arguments.inheritMultifileParts)

compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java

@@ -37,8 +37,6 @@ public class JVMConfigurationKeys {
             CompilerConfigurationKey.create("disable not-null call assertions");
     public static final CompilerConfigurationKey<Boolean> DISABLE_PARAM_ASSERTIONS =
             CompilerConfigurationKey.create("disable not-null parameter assertions");
-    public static final CompilerConfigurationKey<Boolean> DISABLE_INLINE =
-            CompilerConfigurationKey.create("disable inline");
     public static final CompilerConfigurationKey<Boolean> DISABLE_OPTIMIZATION =
             CompilerConfigurationKey.create("disable optimization");
     public static final CompilerConfigurationKey<Boolean> INHERIT_MULTIFILE_PARTS =

compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java

@@ -25,7 +25,12 @@ public class CommonConfigurationKeys {
     }
 
     // roots, including dependencies and own source
-    public static final CompilerConfigurationKey<List<ContentRoot>> CONTENT_ROOTS = CompilerConfigurationKey.create("content roots");
+    public static final CompilerConfigurationKey<List<ContentRoot>> CONTENT_ROOTS =
+            CompilerConfigurationKey.create("content roots");
 
-    public static final CompilerConfigurationKey<List<KotlinScriptDefinition>> SCRIPT_DEFINITIONS_KEY = CompilerConfigurationKey.create("script definitions");
+    public static final CompilerConfigurationKey<List<KotlinScriptDefinition>> SCRIPT_DEFINITIONS_KEY =
+            CompilerConfigurationKey.create("script definitions");
+
+    public static final CompilerConfigurationKey<Boolean> DISABLE_INLINE =
+            CompilerConfigurationKey.create("disable inline");
 }

idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.codegen.ClassBuilderFactories;
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler;
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
@@ -116,7 +117,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
 
             CompilerConfiguration configuration = new CompilerConfiguration();
             if (!enableInline.isSelected()) {
-                configuration.put(JVMConfigurationKeys.DISABLE_INLINE, true);
+                configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
             }
             if (!enableAssertions.isSelected()) {
                 configuration.put(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, true);
@@ -275,7 +276,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
         BindingContext bindingContextForFile = resolutionFacade.analyzeFullyAndGetResult(Collections.singletonList(ktFile)).getBindingContext();
 
         kotlin.Pair<BindingContext, List<KtFile>> result = DebuggerUtils.INSTANCE.analyzeInlinedFunctions(
-                resolutionFacade, bindingContextForFile, ktFile, configuration.getBoolean(JVMConfigurationKeys.DISABLE_INLINE)
+                resolutionFacade, bindingContextForFile, ktFile, configuration.getBoolean(CommonConfigurationKeys.DISABLE_INLINE)
         );
 
         BindingContext bindingContext = result.getFirst();

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

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
@@ -60,9 +61,9 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic
 
     @NotNull
     private JsConfig getConfig() {
-        CompilerConfiguration configuration = getEnvironment().getConfiguration();
+        CompilerConfiguration configuration = getEnvironment().getConfiguration().copy();
+        configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
         return new LibrarySourcesConfig.Builder(getProject(), configuration, "testModule", LibrarySourcesConfig.JS_STDLIB)
-                .inlineEnabled(false)
                 .isUnitTestConfig(true)
                 .build();
     }

idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt

@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.idea.internal
 
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
@@ -42,7 +42,7 @@ abstract class AbstractBytecodeToolWindowTest: KotlinLightCodeInsightFixtureTest
 
         val configuration = CompilerConfiguration()
         if (InTextDirectivesUtils.getPrefixedBoolean(mainFileText, "// INLINE:") == false) {
-            configuration.put(JVMConfigurationKeys.DISABLE_INLINE, true)
+            configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true)
         }
         val bytecodes = KotlinBytecodeToolWindow.getBytecodeForFile(file, configuration)
         assert(bytecodes.contains("// ================")) {

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

@@ -47,7 +47,6 @@ public abstract class JsConfig {
     private final Project project;
     @NotNull
     private final CompilerConfiguration configuration;
-    private final boolean inlineEnabled;
     @NotNull
     private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
     @NotNull
@@ -76,7 +75,6 @@ public abstract class JsConfig {
             @NotNull String moduleId,
             @NotNull EcmaVersion ecmaVersion,
             boolean sourcemap,
-            boolean inlineEnabled,
             boolean metaInfo,
             boolean kjsm
     ) {
@@ -85,11 +83,15 @@ public abstract class JsConfig {
         this.target = ecmaVersion;
         this.moduleId = moduleId;
         this.sourcemap = sourcemap;
-        this.inlineEnabled = inlineEnabled;
         this.metaInfo = metaInfo;
         this.kjsm = kjsm;
     }
 
+    @NotNull
+    public CompilerConfiguration getConfiguration() {
+        return configuration;
+    }
+
     public boolean isSourcemap() {
         return sourcemap;
     }
@@ -102,10 +104,6 @@ public abstract class JsConfig {
         return kjsm;
     }
 
-    public boolean isInlineEnabled() {
-        return inlineEnabled;
-    }
-
     @NotNull
     public Project getProject() {
         return project;

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

@@ -70,12 +70,11 @@ public class LibrarySourcesConfig extends JsConfig {
             @NotNull List<String> files,
             @NotNull EcmaVersion ecmaVersion,
             boolean sourceMap,
-            boolean inlineEnabled,
             boolean isUnitTestConfig,
             boolean metaInfo,
             boolean kjsm
     ) {
-        super(project, configuration, moduleId, ecmaVersion, sourceMap, inlineEnabled, metaInfo, kjsm);
+        super(project, configuration, moduleId, ecmaVersion, sourceMap, metaInfo, kjsm);
         this.files = files;
         this.isUnitTestConfig = isUnitTestConfig;
     }
@@ -197,7 +196,6 @@ public class LibrarySourcesConfig extends JsConfig {
         private final List<String> files;
         private EcmaVersion ecmaVersion = EcmaVersion.defaultVersion();
         boolean sourceMap = false;
-        boolean inlineEnabled = true;
         boolean isUnitTestConfig = false;
         boolean metaInfo = false;
         boolean kjsm = false;
@@ -224,11 +222,6 @@ public class LibrarySourcesConfig extends JsConfig {
             return this;
         }
 
-        public Builder inlineEnabled(boolean inlineEnabled) {
-            this.inlineEnabled = inlineEnabled;
-            return this;
-        }
-
         public Builder isUnitTestConfig(boolean isUnitTestConfig) {
             this.isUnitTestConfig = isUnitTestConfig;
             return this;
@@ -246,7 +239,7 @@ public class LibrarySourcesConfig extends JsConfig {
 
         public JsConfig build() {
             return new LibrarySourcesConfig(
-                    project, configuration, moduleId, files, ecmaVersion, sourceMap, inlineEnabled, isUnitTestConfig, metaInfo, kjsm
+                    project, configuration, moduleId, files, ecmaVersion, sourceMap, isUnitTestConfig, metaInfo, kjsm
             );
         }
     }

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

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.js.JavaScript;
@@ -83,8 +84,7 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
     public static final String TEST_MODULE = "JS_TESTS";
     public static final String TEST_PACKAGE = "foo";
     public static final String TEST_FUNCTION = "box";
-    public static final String NO_INLINE_DIRECTIVE = "// NO_INLINE";
-    public boolean isInlineEnabled = true;
+    private static final String NO_INLINE_DIRECTIVE = "// NO_INLINE";
 
     @NotNull
     private String relativePathToTestDir = "";
@@ -114,7 +114,6 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
         File outDir = new File(getOutputPath());
 
         KotlinTestUtils.mkdirs(outDir);
-        isInlineEnabled = true;
     }
 
     @Override
@@ -326,13 +325,15 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
             @NotNull String moduleId,
             @NotNull EcmaVersion ecmaVersion,
             @Nullable List<String> libraries,
-            List<KtFile> jetFiles
+            @NotNull List<KtFile> files
     ) {
-        for (KtFile file : jetFiles) {
+        CompilerConfiguration configuration = getEnvironment().getConfiguration().copy();
+
+        for (KtFile file : files) {
             String text = file.getText();
 
             if (isDirectiveDefined(text, NO_INLINE_DIRECTIVE)) {
-                isInlineEnabled = false;
+                configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
                 break;
             }
         }
@@ -342,10 +343,9 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
             librariesWithStdlib.addAll(libraries);
         }
 
-        return new LibrarySourcesConfig.Builder(project, getEnvironment().getConfiguration(), moduleId, librariesWithStdlib)
+        return new LibrarySourcesConfig.Builder(project, configuration, moduleId, librariesWithStdlib)
                 .ecmaVersion(ecmaVersion)
                 .sourceMap(shouldGenerateSourceMap())
-                .inlineEnabled(isInlineEnabled)
                 .isUnitTestConfig(shouldBeTranslateAsUnitTestClass())
                 .metaInfo(shouldGenerateMetaInfo())
                 .build();

js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java

@@ -20,6 +20,7 @@ import com.google.dart.compiler.backend.js.ast.*;
 import com.google.gwt.dev.js.ThrowExceptionOnErrorReporter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.js.parser.ParserUtilsKt;
 import org.jetbrains.kotlin.js.resolve.diagnostics.JsCallChecker;
@@ -35,8 +36,8 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil;
 import java.util.List;
 
 import static org.jetbrains.kotlin.js.resolve.diagnostics.JsCallChecker.isJsCall;
-import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getFunctionDescriptor;
 import static org.jetbrains.kotlin.js.translate.utils.InlineUtils.setInlineCallMetadata;
+import static org.jetbrains.kotlin.js.translate.utils.PsiUtils.getFunctionDescriptor;
 import static org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator.getConstant;
 
 public final class CallExpressionTranslator extends AbstractCallExpressionTranslator {
@@ -63,7 +64,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
     }
 
     public static boolean shouldBeInlined(@NotNull KtCallExpression expression, @NotNull TranslationContext context) {
-        if (!context.getConfig().isInlineEnabled()) return false;
+        if (context.getConfig().getConfiguration().getBoolean(CommonConfigurationKeys.DISABLE_INLINE)) return false;
 
         CallableDescriptor descriptor = getFunctionDescriptor(expression, context);
         return shouldBeInlined(descriptor);