diff --git a/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java b/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java index 42b26c0a11c..fd9332ad389 100644 --- a/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java +++ b/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java @@ -23,8 +23,6 @@ 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 org.jetbrains.jet.codegen.optimization.OptimizationUtils; import java.io.File; import java.util.Arrays; @@ -143,7 +141,6 @@ public class BytecodeCompilerTask extends Task { @Override public void execute() { - BytecodeCompiler compiler = new BytecodeCompiler(); String stdlibPath = (this.stdlib != null ? getPath(this.stdlib) : null); String[] classpath = (this.compileClasspath != null ? this.compileClasspath.list() : null); @@ -157,8 +154,8 @@ public class BytecodeCompilerTask extends Task { throw new CompileEnvironmentException(CompilerArgumentsUtil.getWrongCheckOptionErrorMessage("optimize", optimize)); } - boolean enableInline = CompilerArgumentsUtil.optionToBooleanFlag(inline, InlineCodegenUtil.DEFAULT_INLINE_FLAG); - boolean enableOptimization = CompilerArgumentsUtil.optionToBooleanFlag(optimize, OptimizationUtils.DEFAULT_OPTIMIZATION_FLAG); + boolean enableInline = CompilerArgumentsUtil.optionToBooleanFlag(inline, true); + boolean enableOptimization = CompilerArgumentsUtil.optionToBooleanFlag(optimize, true); if (this.src != null) { diff --git a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java index 9da77c6bda8..b6c8f84e636 100644 --- a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java +++ b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java @@ -28,7 +28,9 @@ import org.jetbrains.jet.cli.common.CompilerPlugin; import org.jetbrains.jet.cli.common.messages.MessageCollectorPlainTextToStream; import org.jetbrains.jet.cli.common.modules.ModuleScriptData; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; -import org.jetbrains.jet.cli.jvm.compiler.*; +import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentException; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.utils.KotlinPaths; @@ -125,8 +127,8 @@ public class BytecodeCompiler { } configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollectorPlainTextToStream.PLAIN_TEXT_TO_SYSTEM_ERR); - configuration.put(ENABLE_INLINE, enableInline); - configuration.put(ENABLE_OPTIMIZATION, enableOptimization); + configuration.put(DISABLE_INLINE, !enableInline); + configuration.put(DISABLE_OPTIMIZATION, !enableOptimization); // lets register any compiler plugins configuration.addAll(CLIConfigurationKeys.COMPILER_PLUGINS, getCompilerPlugins()); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 31600ea989c..315c4bbb2de 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -535,7 +535,7 @@ public class AsmUtil { @NotNull FunctionDescriptor descriptor, @NotNull FrameMap frameMap ) { - if (!state.isGenerateNotNullParamAssertions()) return; + if (!state.isParamAssertionsEnabled()) return; // Private method is not accessible from other classes, no assertions needed if (getVisibilityAccessFlag(descriptor) == ACC_PRIVATE) return; @@ -580,7 +580,7 @@ public class AsmUtil { @NotNull CallableDescriptor descriptor, @NotNull String assertMethodToCall ) { - if (!state.isGenerateNotNullAssertions()) return; + if (!state.isCallAssertionsEnabled()) return; if (!isDeclaredInJava(descriptor)) return; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegenUtil.java index 0d2c33d0f69..12779a61e05 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/inline/InlineCodegenUtil.java @@ -59,7 +59,6 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait; public class InlineCodegenUtil { public static final int API = Opcodes.ASM5; public static final String INVOKE = "invoke"; - public static final boolean DEFAULT_INLINE_FLAG = true; public static final String CAPTURED_FIELD_PREFIX = "$"; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationMethodVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationMethodVisitor.java index 1b193a9844e..1b873550b73 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationMethodVisitor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationMethodVisitor.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.codegen.optimization.boxing.RedundantBoxingMethodTransf import org.jetbrains.jet.codegen.optimization.boxing.RedundantNullCheckMethodTransformer; import org.jetbrains.jet.codegen.optimization.transformer.MethodTransformer; import org.jetbrains.org.objectweb.asm.MethodVisitor; +import org.jetbrains.org.objectweb.asm.Opcodes; import org.jetbrains.org.objectweb.asm.tree.LocalVariableNode; import org.jetbrains.org.objectweb.asm.tree.MethodNode; import org.jetbrains.org.objectweb.asm.util.Textifier; @@ -48,7 +49,7 @@ public class OptimizationMethodVisitor extends MethodVisitor { @Nullable String signature, @Nullable String[] exceptions ) { - super(OptimizationUtils.API); + super(Opcodes.ASM5); this.delegate = delegate; this.methodNode = new MethodNode(access, name, desc, signature, exceptions); this.methodNode.localVariables = new ArrayList(5); @@ -69,7 +70,7 @@ public class OptimizationMethodVisitor extends MethodVisitor { MAIN_METHOD_TRANSFORMER.transform("fake", methodNode); } - methodNode.accept(new EndIgnoringMethodVisitorDecorator(OptimizationUtils.API, delegate)); + methodNode.accept(new EndIgnoringMethodVisitorDecorator(Opcodes.ASM5, delegate)); // In case of empty instructions list MethodNode.accept doesn't call visitLocalVariables of delegate diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationUtils.java b/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationUtils.java deleted file mode 100644 index 6130e8ce73c..00000000000 --- a/compiler/backend/src/org/jetbrains/jet/codegen/optimization/OptimizationUtils.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * 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.codegen.optimization; - -import org.jetbrains.org.objectweb.asm.Opcodes; - -public class OptimizationUtils { - public final static int API = Opcodes.ASM5; - public static final boolean DEFAULT_OPTIMIZATION_FLAG = true; -} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java b/compiler/backend/src/org/jetbrains/jet/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java index 55708b4da92..3d88aef19b6 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/optimization/boxing/RedundantBoxingMethodTransformer.java @@ -20,7 +20,6 @@ import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.codegen.optimization.OptimizationUtils; import org.jetbrains.jet.codegen.optimization.transformer.MethodTransformer; import org.jetbrains.org.objectweb.asm.Opcodes; import org.jetbrains.org.objectweb.asm.Type; @@ -279,7 +278,7 @@ public class RedundantBoxingMethodTransformer extends MethodTransformer { @NotNull Pair castWithType ) { AbstractInsnNode castInsn = castWithType.getFirst(); - MethodNode castInsnsListener = new MethodNode(OptimizationUtils.API); + MethodNode castInsnsListener = new MethodNode(Opcodes.ASM5); new InstructionAdapter(castInsnsListener).cast(value.getPrimitiveType(), castWithType.getSecond()); for (AbstractInsnNode insn : castInsnsListener.instructions.toArray()) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java index c94123338bc..c872d036635 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java @@ -21,10 +21,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.codegen.*; 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.codegen.optimization.OptimizationClassBuilderFactory; -import org.jetbrains.jet.codegen.optimization.OptimizationUtils; import org.jetbrains.jet.codegen.when.MappingsClassesForWhenByEnum; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; @@ -89,13 +87,13 @@ public class GenerationState { @NotNull private final JetTypeMapper typeMapper; - private final boolean generateNotNullAssertions; + private final boolean disableCallAssertions; - private final boolean generateNotNullParamAssertions; + private final boolean disableParamAssertions; private final GenerateClassFilter generateClassFilter; - private final boolean inlineEnabled; + private final boolean disableInline; @Nullable private List earlierScriptsForReplInterpreter; @@ -121,10 +119,8 @@ public class GenerationState { @NotNull BindingContext bindingContext, @NotNull List files ) { - this(project, builderFactory, Progress.DEAF, module, bindingContext, files, true, false, GenerateClassFilter.GENERATE_ALL, - InlineCodegenUtil.DEFAULT_INLINE_FLAG, OptimizationUtils.DEFAULT_OPTIMIZATION_FLAG, - null, null, DiagnosticHolder.DO_NOTHING, null - ); + this(project, builderFactory, Progress.DEAF, module, bindingContext, files, true, true, GenerateClassFilter.GENERATE_ALL, + false, false, null, null, DiagnosticHolder.DO_NOTHING, null); } public GenerationState( @@ -134,11 +130,11 @@ public class GenerationState { @NotNull ModuleDescriptor module, @NotNull BindingContext bindingContext, @NotNull List files, - boolean generateNotNullAssertions, - boolean generateNotNullParamAssertions, + boolean disableCallAssertions, + boolean disableParamAssertions, GenerateClassFilter generateClassFilter, - boolean inlineEnabled, - boolean optimizationEnabled, + boolean disableInline, + boolean disableOptimization, @Nullable Collection packagesWithRemovedFiles, @Nullable String moduleId, @NotNull DiagnosticHolder diagnostics, @@ -151,7 +147,7 @@ public class GenerationState { this.moduleId = moduleId; this.packagesWithRemovedFiles = packagesWithRemovedFiles == null ? Collections.emptySet() : packagesWithRemovedFiles; this.classBuilderMode = builderFactory.getClassBuilderMode(); - this.inlineEnabled = inlineEnabled; + this.disableInline = disableInline; this.bindingTrace = new DelegatingBindingTrace(bindingContext, "trace in GenerationState"); this.bindingContext = bindingTrace.getBindingContext(); @@ -161,15 +157,15 @@ public class GenerationState { this.intrinsics = new IntrinsicMethods(); - if (optimizationEnabled) { + if (!disableOptimization) { builderFactory = new OptimizationClassBuilderFactory(builderFactory); } this.classFileFactory = new ClassFileFactory(this, new BuilderFactoryForDuplicateSignatureDiagnostics( builderFactory, this.bindingContext, diagnostics)); - this.generateNotNullAssertions = generateNotNullAssertions; - this.generateNotNullParamAssertions = generateNotNullParamAssertions; + this.disableCallAssertions = disableCallAssertions; + this.disableParamAssertions = disableParamAssertions; this.generateClassFilter = generateClassFilter; ReflectionTypes reflectionTypes = new ReflectionTypes(module); @@ -231,12 +227,12 @@ public class GenerationState { return mappingsClassesForWhenByEnum; } - public boolean isGenerateNotNullAssertions() { - return generateNotNullAssertions; + public boolean isCallAssertionsEnabled() { + return !disableCallAssertions; } - public boolean isGenerateNotNullParamAssertions() { - return generateNotNullParamAssertions; + public boolean isParamAssertionsEnabled() { + return !disableParamAssertions; } @NotNull @@ -250,7 +246,7 @@ public class GenerationState { } public boolean isInlineEnabled() { - return inlineEnabled; + return !disableInline; } public void beforeCompile() { diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/JVMConfigurationKeys.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/JVMConfigurationKeys.java index 94579dceb4a..37cc75f7743 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/JVMConfigurationKeys.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/JVMConfigurationKeys.java @@ -31,16 +31,14 @@ public class JVMConfigurationKeys { public static final CompilerConfigurationKey> SCRIPT_PARAMETERS = CompilerConfigurationKey.create("script"); - public static final CompilerConfigurationKey GENERATE_NOT_NULL_ASSERTIONS = - CompilerConfigurationKey.create("generate not-null assertions"); - public static final CompilerConfigurationKey GENERATE_NOT_NULL_PARAMETER_ASSERTIONS = - CompilerConfigurationKey.create("generate not-null parameter assertions"); - - public static final CompilerConfigurationKey ENABLE_INLINE = - CompilerConfigurationKey.create("enable inline"); - - public static final CompilerConfigurationKey ENABLE_OPTIMIZATION = - CompilerConfigurationKey.create("enable optimization"); + public static final CompilerConfigurationKey DISABLE_CALL_ASSERTIONS = + CompilerConfigurationKey.create("disable not-null call assertions"); + public static final CompilerConfigurationKey DISABLE_PARAM_ASSERTIONS = + CompilerConfigurationKey.create("disable not-null parameter assertions"); + public static final CompilerConfigurationKey DISABLE_INLINE = + CompilerConfigurationKey.create("disable inline"); + public static final CompilerConfigurationKey DISABLE_OPTIMIZATION = + CompilerConfigurationKey.create("disable optimization"); public static final CompilerConfigurationKey INCREMENTAL_CACHE_BASE_DIR = CompilerConfigurationKey.create("incremental cache base dir"); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java index 9473e50dce1..befc144676e 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java @@ -100,10 +100,10 @@ public class K2JVMCompiler extends CLICompiler { ? CommandLineScriptUtils.scriptParameters() : Collections.emptyList()); - configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, !arguments.noCallAssertions); - configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, !arguments.noParamAssertions); - configuration.put(JVMConfigurationKeys.ENABLE_INLINE, !arguments.noInline); - configuration.put(JVMConfigurationKeys.ENABLE_OPTIMIZATION, !arguments.noOptimize); + 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(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 09bca946218..18afefc703a 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -39,8 +39,6 @@ import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.codegen.*; -import org.jetbrains.jet.codegen.inline.InlineCodegenUtil; -import org.jetbrains.jet.codegen.optimization.OptimizationUtils; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.Progress; import org.jetbrains.jet.config.CommonConfigurationKeys; @@ -369,15 +367,16 @@ public class KotlinToJVMBytecodeCompiler { exhaust.getModuleDescriptor(), exhaust.getBindingContext(), sourceFiles, - configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, false), - configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, false), + configuration.get(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false), + configuration.get(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false), GenerationState.GenerateClassFilter.GENERATE_ALL, - configuration.get(JVMConfigurationKeys.ENABLE_INLINE, InlineCodegenUtil.DEFAULT_INLINE_FLAG), - configuration.get(JVMConfigurationKeys.ENABLE_OPTIMIZATION, OptimizationUtils.DEFAULT_OPTIMIZATION_FLAG), + configuration.get(JVMConfigurationKeys.DISABLE_INLINE, false), + configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false), packagesWithRemovedFiles, moduleId, diagnosticHolder, - outputDirectory); + outputDirectory + ); KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION); AnalyzerWithCompilerReport.reportDiagnostics( new FilteredJvmDiagnostics( diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java index 3dd904ba226..799b46c63ee 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java @@ -294,14 +294,15 @@ public class KotlinJavaFileStubProvideralwaysTrue()); + Predicates.alwaysTrue() + ); analyzeExhaust.throwIfError(); AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); CompilerConfiguration configuration = environment.getConfiguration(); @@ -65,15 +64,16 @@ public class CodegenTestUtil { GenerationState state = new GenerationState( environment.getProject(), ClassBuilderFactories.TEST, Progress.DEAF, analyzeExhaust.getModuleDescriptor(), analyzeExhaust.getBindingContext(), files.getPsiFiles(), - configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, true), - configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, true), + configuration.get(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false), + configuration.get(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false), GenerationState.GenerateClassFilter.GENERATE_ALL, - configuration.get(JVMConfigurationKeys.ENABLE_INLINE, InlineCodegenUtil.DEFAULT_INLINE_FLAG), - configuration.get(JVMConfigurationKeys.ENABLE_OPTIMIZATION, OptimizationUtils.DEFAULT_OPTIMIZATION_FLAG), + configuration.get(JVMConfigurationKeys.DISABLE_INLINE, false), + configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false), null, null, forExtraDiagnostics, - null); + null + ); KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION); // For JVM-specific errors diff --git a/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java b/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java index 23c7b0c1a9e..d450773a711 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java @@ -41,35 +41,35 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { super.setUp(); } - private void setUpEnvironment(boolean generateAssertions, boolean generateParamAssertions, File... extraClassPath) { + private void setUpEnvironment(boolean disableCallAssertions, boolean disableParamAssertions, File... extraClassPath) { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, extraClassPath); - configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, generateAssertions); - configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, generateParamAssertions); + configuration.put(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, disableCallAssertions); + configuration.put(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, disableParamAssertions); myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); } - private void doTestGenerateAssertions(boolean generateAssertions) throws Exception { + private void doTestCallAssertions(boolean disableCallAssertions) throws Exception { File javaClassesTempDirectory = compileJava("notNullAssertions/A.java"); - setUpEnvironment(generateAssertions, false, javaClassesTempDirectory); + setUpEnvironment(disableCallAssertions, true, javaClassesTempDirectory); loadFile("notNullAssertions/AssertionChecker.kt"); - generateFunction("checkAssertions").invoke(null, generateAssertions); + generateFunction("checkAssertions").invoke(null, !disableCallAssertions); } public void testGenerateAssertions() throws Exception { - doTestGenerateAssertions(true); + doTestCallAssertions(false); } public void testDoNotGenerateAssertions() throws Exception { - doTestGenerateAssertions(false); + doTestCallAssertions(true); } public void testNoAssertionsForKotlinFromSource() throws Exception { - setUpEnvironment(true, false); + setUpEnvironment(false, true); loadFiles("notNullAssertions/noAssertionsForKotlin.kt", "notNullAssertions/noAssertionsForKotlinMain.kt"); @@ -77,13 +77,13 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } public void testNoAssertionsForKotlinFromBinary() throws Exception { - setUpEnvironment(true, false); + setUpEnvironment(false, true); loadFile("notNullAssertions/noAssertionsForKotlin.kt"); OutputFileCollection outputFiles = generateClassesInFile(); File compiledDirectory = new File(FileUtil.getTempDirectory(), "kotlin-classes"); OutputUtilsPackage.writeAllTo(outputFiles, compiledDirectory); - setUpEnvironment(true, false, compiledDirectory); + setUpEnvironment(false, true, compiledDirectory); loadFile("notNullAssertions/noAssertionsForKotlinMain.kt"); assertNoIntrinsicsMethodIsCalled(PackageClassUtils.getPackageClassName(FqName.ROOT)); @@ -92,14 +92,14 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { public void testGenerateParamAssertions() throws Exception { File javaClassesTempDirectory = compileJava("notNullAssertions/doGenerateParamAssertions.java"); - setUpEnvironment(false, true, javaClassesTempDirectory); + setUpEnvironment(true, false, javaClassesTempDirectory); loadFile("notNullAssertions/doGenerateParamAssertions.kt"); generateFunction().invoke(null); } public void testDoNotGenerateParamAssertions() throws Exception { - setUpEnvironment(false, false); + setUpEnvironment(true, true); loadFile("notNullAssertions/doNotGenerateParamAssertions.kt"); @@ -107,7 +107,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } public void testNoParamAssertionForPrivateMethod() throws Exception { - setUpEnvironment(false, true); + setUpEnvironment(true, false); loadFile("notNullAssertions/noAssertionForPrivateMethod.kt"); @@ -115,7 +115,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } public void testArrayListGet() { - setUpEnvironment(true, true); + setUpEnvironment(false, false); loadFile("notNullAssertions/arrayListGet.kt"); String text = generateToText(); @@ -126,7 +126,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { public void testJavaMultipleSubstitutions() { File javaClassesTempDirectory = compileJava("notNullAssertions/javaMultipleSubstitutions.java"); - setUpEnvironment(true, true, javaClassesTempDirectory); + setUpEnvironment(false, false, javaClassesTempDirectory); loadFile("notNullAssertions/javaMultipleSubstitutions.kt"); String text = generateToText(); @@ -136,7 +136,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } public void testAssertionForNotNullTypeParam() { - setUpEnvironment(true, true); + setUpEnvironment(false, false); loadFile("notNullAssertions/assertionForNotNullTypeParam.kt"); @@ -144,7 +144,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } public void testNoAssertionForNullableGenericMethod() { - setUpEnvironment(true, false); + setUpEnvironment(false, true); loadFile("notNullAssertions/noAssertionForNullableGenericMethod.kt"); @@ -152,7 +152,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { } public void testNoAssertionForNullableGenericMethodCall() { - setUpEnvironment(true, false); + setUpEnvironment(false, true); loadFile("notNullAssertions/noAssertionForNullableGenericMethodCall.kt"); diff --git a/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java b/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java index e9821bada9c..e7aa9f73eb7 100644 --- a/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java +++ b/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java @@ -115,7 +115,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable { exhaust.getModuleDescriptor(), exhaust.getBindingContext(), Collections.singletonList(jetFile), true, true, GenerationState.GenerateClassFilter.GENERATE_ALL, - enableInline.isSelected(), enableOptimization.isSelected(), null, null, + !enableInline.isSelected(), !enableOptimization.isSelected(), null, null, DiagnosticHolder.DO_NOTHING, null); KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION); }