Move default inline flag to JVM back-end

- other back-ends are likely to have its own value of this flag
- get rid of DEFAULT_INLINE_FLAG_FOR_TEST
- the main goal was to simplify the default GenerationState constructor, which
  now always uses default inline flag value

build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.buildtools.core.BytecodeCompiler;
 import org.jetbrains.jet.buildtools.core.Util;
 import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentException;
+import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
 
 import java.io.File;
 import java.util.Arrays;
@@ -142,11 +143,11 @@ public class BytecodeCompilerTask extends Task {
         String[] classpath = (this.compileClasspath != null ? this.compileClasspath.list() : null);
         String[] externalAnnotationsPath = (this.externalAnnotations != null) ? this.externalAnnotations.list() : null;
 
-        if (!CompilerArgumentsUtil.checkInlineOption(inline)) {
+        if (!CompilerArgumentsUtil.checkOption(inline)) {
-            throw new CompileEnvironmentException(CompilerArgumentsUtil.getWrongOptionErrorMessage(inline));
+            throw new CompileEnvironmentException(CompilerArgumentsUtil.getWrongInlineOptionErrorMessage(inline));
         }
 
-        boolean enableInline = CompilerArgumentsUtil.optionToInlineFlag(inline);
+        boolean enableInline = CompilerArgumentsUtil.optionToBooleanFlag(inline, InlineCodegenUtil.DEFAULT_INLINE_FLAG);
 
         if (this.src != null) {
 

compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegenUtil.java

@@ -23,8 +23,6 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.org.objectweb.asm.*;
-import org.jetbrains.org.objectweb.asm.tree.MethodNode;
 import org.jetbrains.jet.codegen.PackageCodegen;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.context.CodegenContext;
@@ -43,6 +41,8 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.tree.MethodNode;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -52,10 +52,9 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getFqName;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait;
 
 public class InlineCodegenUtil {
-
+    public static final int API = Opcodes.ASM5;
-    public final static int API = Opcodes.ASM5;
+    public static final String INVOKE = "invoke";
-
+    public static final boolean DEFAULT_INLINE_FLAG = true;
-    public final static String INVOKE = "invoke";
 
     @Nullable
     public static MethodNode getMethodNode(

compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.codegen.ClassBuilderMode;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.SamWrapperClasses;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
+import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
@@ -100,10 +101,10 @@ public class GenerationState {
             @NotNull Project project,
             @NotNull ClassBuilderFactory builderFactory,
             @NotNull BindingContext bindingContext,
-            @NotNull List<JetFile> files,
+            @NotNull List<JetFile> files
-            boolean inlineEnabled
     ) {
-        this(project, builderFactory, Progress.DEAF, bindingContext, files, true, false, GenerateClassFilter.GENERATE_ALL, inlineEnabled);
+        this(project, builderFactory, Progress.DEAF, bindingContext, files, true, false, GenerateClassFilter.GENERATE_ALL,
+             InlineCodegenUtil.DEFAULT_INLINE_FLAG);
     }
 
     public GenerationState(

compiler/cli/cli-common/src/org/jetbrains/jet/cli/common/arguments/CompilerArgumentsUtil.java

@@ -19,27 +19,21 @@ package org.jetbrains.jet.cli.common.arguments;
 import org.jetbrains.annotations.Nullable;
 
 public class CompilerArgumentsUtil {
-    public static final boolean DEFAULT_INLINE_FLAG = true;
+    public static boolean optionToBooleanFlag(@Nullable String option, boolean defaultValue) {
-    public static final boolean DEFAULT_INLINE_FLAG_FOR_TEST = true;
+        boolean enabled = "on".equalsIgnoreCase(option) || "true".equalsIgnoreCase(option);
-
+        boolean disabled = "off".equalsIgnoreCase(option) || "false".equalsIgnoreCase(option);
-    public static boolean optionToInlineFlag(@Nullable String option) {
+        return (enabled || disabled) ? enabled : defaultValue;
-        boolean enableInline = "on".equalsIgnoreCase(option) || "true".equalsIgnoreCase(option);
-        return (enableInline || "off".equalsIgnoreCase(option) || "false".equalsIgnoreCase(option)) ? enableInline : DEFAULT_INLINE_FLAG;
     }
 
-    public static boolean checkInlineOption(@Nullable String option)  {
+    public static boolean checkOption(@Nullable String option)  {
-        if (option == null ||
+        return option == null ||
-            "on".equalsIgnoreCase(option) ||
+               "on".equalsIgnoreCase(option) ||
-            "off".equalsIgnoreCase(option) ||
+               "off".equalsIgnoreCase(option) ||
-            "true".equalsIgnoreCase(option) ||
+               "true".equalsIgnoreCase(option) ||
-            "false".equalsIgnoreCase(option)) {
+               "false".equalsIgnoreCase(option);
-            return true;
-        }
-
-        return false;
     }
 
-    public static String getWrongOptionErrorMessage(@Nullable String inline) {
+    public static String getWrongInlineOptionErrorMessage(@Nullable String inline) {
         return "Wrong value for inline option: '" + inline + "'. Should be 'on'/'off' or 'true'/'false'";
     }
 }

compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.cli.common.messages.*;
 import org.jetbrains.jet.cli.jvm.compiler.*;
 import org.jetbrains.jet.cli.jvm.repl.ReplFromTerminal;
 import org.jetbrains.jet.codegen.CompilationException;
+import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
@@ -108,7 +109,8 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
 
         configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, arguments.notNullAssertions);
         configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, arguments.notNullParamAssertions);
-        configuration.put(JVMConfigurationKeys.ENABLE_INLINE, CompilerArgumentsUtil.optionToInlineFlag(arguments.inline));
+        configuration.put(JVMConfigurationKeys.ENABLE_INLINE,
+                          CompilerArgumentsUtil.optionToBooleanFlag(arguments.inline, InlineCodegenUtil.DEFAULT_INLINE_FLAG));
 
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector);
 
@@ -197,8 +199,8 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
     protected void checkArguments(@NotNull K2JVMCompilerArguments argument) {
         super.checkArguments(argument);
 
-        if (!CompilerArgumentsUtil.checkInlineOption(argument.inline)) {
+        if (!CompilerArgumentsUtil.checkOption(argument.inline)) {
-            throw new IllegalArgumentException(CompilerArgumentsUtil.getWrongOptionErrorMessage(argument.inline));
+            throw new IllegalArgumentException(CompilerArgumentsUtil.getWrongInlineOptionErrorMessage(argument.inline));
         }
     }
 

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -29,13 +29,13 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.common.CLIConfigurationKeys;
 import org.jetbrains.jet.cli.common.CompilerPlugin;
 import org.jetbrains.jet.cli.common.CompilerPluginContext;
-import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.cli.common.output.OutputDirector;
 import org.jetbrains.jet.cli.common.output.SingleDirectoryDirector;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.Progress;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
@@ -309,7 +309,7 @@ public class KotlinToJVMBytecodeCompiler {
                 configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, false),
                 configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, false),
                 GenerationState.GenerateClassFilter.GENERATE_ALL,
-                configuration.get(JVMConfigurationKeys.ENABLE_INLINE, CompilerArgumentsUtil.DEFAULT_INLINE_FLAG)
+                configuration.get(JVMConfigurationKeys.ENABLE_INLINE, InlineCodegenUtil.DEFAULT_INLINE_FLAG)
         );
         KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION);
         return generationState;

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -29,10 +29,8 @@ import com.intellij.psi.impl.PsiFileFactoryImpl;
 import com.intellij.testFramework.LightVirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.jet.OutputFile;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.cli.common.messages.MessageCollectorToString;
@@ -63,6 +61,7 @@ import org.jetbrains.jet.plugin.JetLanguage;
 import org.jetbrains.jet.storage.ExceptionTracker;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.utils.UtilsPackage;
+import org.jetbrains.org.objectweb.asm.Type;
 
 import java.io.File;
 import java.io.PrintWriter;
@@ -249,7 +248,7 @@ public class ReplInterpreter {
 
         BindingContext bindingContext = AnalyzeExhaust.success(trace.getBindingContext(), module).getBindingContext();
         GenerationState generationState = new GenerationState(psiFile.getProject(), ClassBuilderFactories.BINARIES,
-                                                              bindingContext, Collections.singletonList(psiFile), CompilerArgumentsUtil.DEFAULT_INLINE_FLAG);
+                                                              bindingContext, Collections.singletonList(psiFile));
 
         compileScript(psiFile.getScript(), scriptClassType, earlierScripts, generationState,
                       CompilationErrorHandler.THROW_EXCEPTION);

compiler/integration-tests/testData/inlineWrongArg/build.log.expected

@@ -7,7 +7,7 @@ ERR:
 
 BUILD FAILED
 [TestData]/build.xml:5: org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentException: Wrong value for inline option: 'wrong'. Should be 'on'/'off' or 'true'/'false'
-	at org.jetbrains.jet.buildtools.ant.BytecodeCompilerTask.execute(BytecodeCompilerTask.java:146)
+	at org.jetbrains.jet.buildtools.ant.BytecodeCompilerTask.execute(BytecodeCompilerTask.java:147)
 	at org.apache.tools.ant.UnknownElement.execute(UnknownElement.java:291)
 	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)

compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java

@@ -23,10 +23,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
+import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.Progress;
 import org.jetbrains.jet.config.CompilerConfiguration;
@@ -61,7 +61,7 @@ public class CodegenTestUtil {
                 configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, true),
                 configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, true),
                 GenerationState.GenerateClassFilter.GENERATE_ALL,
-                configuration.get(JVMConfigurationKeys.ENABLE_INLINE, CompilerArgumentsUtil.DEFAULT_INLINE_FLAG_FOR_TEST)
+                configuration.get(JVMConfigurationKeys.ENABLE_INLINE, InlineCodegenUtil.DEFAULT_INLINE_FLAG)
         );
         KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
         return state.getFactory();

compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java

@@ -21,7 +21,6 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
@@ -41,8 +40,7 @@ public class GenerationUtils {
 
     @NotNull
     public static GenerationState compileFileGetGenerationStateForTest(@NotNull JetFile psiFile) {
-        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
+        AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile);
-                psiFile);
         return compileFilesGetGenerationState(psiFile.getProject(), analyzeExhaust, Collections.singletonList(psiFile));
     }
 
@@ -57,8 +55,7 @@ public class GenerationUtils {
     @NotNull
     public static GenerationState compileFilesGetGenerationState(@NotNull Project project, @NotNull AnalyzeExhaust analyzeExhaust, @NotNull List<JetFile> files) {
         analyzeExhaust.throwIfError();
-        GenerationState state = new GenerationState(project, ClassBuilderFactories.TEST, analyzeExhaust.getBindingContext(), files,
+        GenerationState state = new GenerationState(project, ClassBuilderFactories.TEST, analyzeExhaust.getBindingContext(), files);
-                                                    CompilerArgumentsUtil.DEFAULT_INLINE_FLAG_FOR_TEST);
         KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
         return state;
     }

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -43,8 +43,6 @@ import org.jetbrains.eval4j.jdi.asJdiValue
 import org.jetbrains.eval4j.jdi.makeInitialFrame
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 import org.jetbrains.jet.lang.resolve.name.FqName
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
-import org.jetbrains.jet.plugin.debugger.KotlinEditorTextProvider
 import org.jetbrains.jet.lang.psi.JetPsiFactory
 import org.jetbrains.eval4j.jdi.asValue
 import org.jetbrains.jet.plugin.refactoring.createTempCopy
@@ -53,20 +51,15 @@ import org.jetbrains.jet.plugin.refactoring.extractFunction.performAnalysis
 import org.jetbrains.jet.plugin.util.MaybeError
 import org.jetbrains.jet.plugin.util.MaybeValue
 import org.jetbrains.jet.plugin.refactoring.extractFunction.validate
-import org.jetbrains.jet.plugin.refactoring.checkConflictsInteractively
 import org.jetbrains.jet.plugin.refactoring.extractFunction.generateFunction
-import com.intellij.util.text.CharArrayUtil
 import org.jetbrains.jet.lang.psi.JetNamedFunction
-import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiFile
 import org.jetbrains.jet.codegen.ClassFileFactory
 import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils
 import org.jetbrains.jet.OutputFileCollection
 import org.jetbrains.jet.lang.psi.JetExpressionCodeFragment
-import org.jetbrains.jet.lang.psi.JetExpressionCodeFragment
 import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults
 import org.jetbrains.jet.lang.psi.JetCodeFragment
-import org.jetbrains.jet.lang.resolve.ImportPath
 import org.jetbrains.jet.lang.psi.JetImportList
 import org.jetbrains.jet.lang.psi.JetExpression
 
@@ -192,8 +185,8 @@ class KotlinEvaluator(val codeFragment: JetExpressionCodeFragment,
                         file.getProject(),
                         ClassBuilderFactories.BINARIES,
                         bindingContext,
-                        Collections.singletonList(file),
+                        listOf(file)
-                        true)
+                )
 
                 KotlinCodegenFacade.compileCorrectFiles(state) {
                     e, msg ->

libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -117,8 +117,8 @@ public open class KotlinCompile(): AbstractCompile() {
         args.noJdkAnnotations = true
         args.inline = kotlinOptions.inline
 
-        if (!CompilerArgumentsUtil.checkInlineOption(args.inline)) {
+        if (!CompilerArgumentsUtil.checkOption(args.inline)) {
-            throw GradleException(CompilerArgumentsUtil.getWrongOptionErrorMessage(args.inline))
+            throw GradleException(CompilerArgumentsUtil.getWrongInlineOptionErrorMessage(args.inline))
         }
 
         val messageCollector = GradleMessageCollector(logger)

libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java

@@ -34,6 +34,7 @@ import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.cli.jvm.K2JVMCompiler;
 import org.jetbrains.jet.cli.common.arguments.CompilerArgumentsUtil;
+import org.jetbrains.jet.codegen.inline.InlineCodegenUtil;
 
 import java.io.File;
 import java.io.IOException;
@@ -313,10 +314,10 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo {
         arguments.annotations = getFullAnnotationsPath(log, annotationPaths);
         log.info("Using kotlin annotations from " + arguments.annotations);
         arguments.inline = inline;
-        if (!CompilerArgumentsUtil.checkInlineOption(arguments.inline)) {
+        if (!CompilerArgumentsUtil.checkOption(arguments.inline)) {
-            throw new MojoExecutionException(CompilerArgumentsUtil.getWrongOptionErrorMessage(arguments.inline));
+            throw new MojoExecutionException(CompilerArgumentsUtil.getWrongInlineOptionErrorMessage(arguments.inline));
         }
-        log.info("Method inlining is " + CompilerArgumentsUtil.optionToInlineFlag(arguments.inline));
+        log.info("Method inlining is " + CompilerArgumentsUtil.optionToBooleanFlag(arguments.inline, InlineCodegenUtil.DEFAULT_INLINE_FLAG));
     }
 
     protected String getFullAnnotationsPath(Log log, List<String> annotations) {