diff --git a/java/compiler/impl/src/com/intellij/compiler/CompilerConfigurationImpl.java b/java/compiler/impl/src/com/intellij/compiler/CompilerConfigurationImpl.java index 35c02a43e760..28efa9788aad 100644 --- a/java/compiler/impl/src/com/intellij/compiler/CompilerConfigurationImpl.java +++ b/java/compiler/impl/src/com/intellij/compiler/CompilerConfigurationImpl.java @@ -79,7 +79,8 @@ import java.util.*; ) public class CompilerConfigurationImpl extends CompilerConfiguration implements PersistentStateComponent, ProjectComponent { private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.CompilerConfiguration"); - @NonNls public static final String TESTS_EXTERNAL_COMPILER_HOME_PROPERTY_NAME = "tests.external.compiler.home"; + public static final String TESTS_EXTERNAL_COMPILER_HOME_PROPERTY_NAME = "tests.external.compiler.home"; + public static final int DEFAULT_BUILD_PROCESS_HEAP_SIZE = 700; private BackendCompiler myDefaultJavaCompiler; private State myState = new State(); @@ -133,6 +134,8 @@ public class CompilerConfigurationImpl extends CompilerConfiguration implements private static class State { public String DEFAULT_COMPILER = JavaCompilers.JAVAC_ID; + public int BUILD_PROCESS_HEAP_SIZE = DEFAULT_BUILD_PROCESS_HEAP_SIZE; + public String BUILD_PROCESS_ADDITIONAL_VM_OPTIONS = ""; private boolean compilerWasSpecified; } @@ -203,6 +206,27 @@ public class CompilerConfigurationImpl extends CompilerConfiguration implements readExternal(state); } + public int getBuildProcessHeapSize(final int javacPreferredHeapSize) { + final int heapSize = myState.BUILD_PROCESS_HEAP_SIZE; + if (heapSize != DEFAULT_BUILD_PROCESS_HEAP_SIZE) { + return heapSize; + } + // compatibility with older builds: if javac is set to use larger heap, and if so, use it. + return Math.max(heapSize, javacPreferredHeapSize); + } + + public void setBuildProcessHeapSize(int size) { + myState.BUILD_PROCESS_HEAP_SIZE = size > 0? size : DEFAULT_BUILD_PROCESS_HEAP_SIZE; + } + + public String getBuildProcessVMOptions() { + return myState.BUILD_PROCESS_ADDITIONAL_VM_OPTIONS; + } + + public void setBuildProcessVMOptions(String options) { + myState.BUILD_PROCESS_ADDITIONAL_VM_OPTIONS = options == null? "" : options.trim(); + } + @Override public void setProjectBytecodeTarget(@Nullable String level) { final String previous = myBytecodeTargetLevel; @@ -653,9 +677,13 @@ public class CompilerConfigurationImpl extends CompilerConfiguration implements public void readExternal(Element parentNode) { myState = XmlSerializer.deserialize(parentNode, State.class); - Element option = parentNode.getChild("option"); if (!myProject.isDefault()) { - myState.compilerWasSpecified = option != null && "DEFAULT_COMPILER".equals(option.getAttributeValue("name")); + for (Element option : parentNode.getChildren("option")) { + if ("DEFAULT_COMPILER".equals(option.getAttributeValue("name"))) { + myState.compilerWasSpecified = true; + break; + } + } } final Element notNullAssertions = parentNode.getChild(JpsJavaCompilerConfigurationSerializer.ADD_NOTNULL_ASSERTIONS); diff --git a/java/compiler/impl/src/com/intellij/compiler/ant/BuildPropertiesImpl.java b/java/compiler/impl/src/com/intellij/compiler/ant/BuildPropertiesImpl.java index 0072c77d0b98..5446a6aed389 100644 --- a/java/compiler/impl/src/com/intellij/compiler/ant/BuildPropertiesImpl.java +++ b/java/compiler/impl/src/com/intellij/compiler/ant/BuildPropertiesImpl.java @@ -15,7 +15,7 @@ */ package com.intellij.compiler.ant; -import com.intellij.compiler.CompilerWorkspaceConfiguration; +import com.intellij.compiler.CompilerConfiguration; import com.intellij.compiler.ant.taskdefs.*; import com.intellij.compiler.impl.javaCompiler.javac.JavacConfiguration; import com.intellij.openapi.compiler.CompilerBundle; @@ -58,7 +58,7 @@ public class BuildPropertiesImpl extends BuildProperties { add(new Property(PROPERTY_COMPILER_GENERATE_NO_WARNINGS, javacSettings.GENERATE_NO_WARNINGS ? "on" : "off")); add(new Property(PROPERTY_COMPILER_ADDITIONAL_ARGS, javacSettings.ADDITIONAL_OPTIONS_STRING)); //noinspection HardCodedStringLiteral - final int heapSize = CompilerWorkspaceConfiguration.getInstance(project).getProcessHeapSize(javacSettings.MAXIMUM_HEAP_SIZE); + final int heapSize = CompilerConfiguration.getInstance(project).getBuildProcessHeapSize(javacSettings.MAXIMUM_HEAP_SIZE); add(new Property(PROPERTY_COMPILER_MAX_MEMORY, Integer.toString(heapSize) + "m")); add(new IgnoredFiles()); diff --git a/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form b/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form index 54f8d35e51ad..44cfb15538fb 100644 --- a/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form +++ b/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form @@ -1,6 +1,6 @@
- + @@ -10,7 +10,7 @@ - + @@ -102,20 +102,12 @@ - + - + - - - - - - - - @@ -156,6 +148,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java b/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java index 9478572be570..60613b5fba38 100644 --- a/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java +++ b/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java @@ -28,6 +28,7 @@ import com.intellij.openapi.options.Configurable; import com.intellij.openapi.options.ConfigurationException; import com.intellij.openapi.options.SearchableConfigurable; import com.intellij.openapi.project.Project; +import com.intellij.ui.DocumentAdapter; import com.intellij.ui.Gray; import com.intellij.ui.JBColor; import com.intellij.ui.RawCommandLineEditor; @@ -38,6 +39,7 @@ import com.intellij.xml.util.XmlStringUtil; import org.jetbrains.annotations.NotNull; import javax.swing.*; +import javax.swing.event.DocumentEvent; import java.awt.*; import java.util.*; import java.util.List; @@ -66,8 +68,10 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura private JCheckBox myCbEnableAutomake; private JCheckBox myCbParallelCompilation; private JTextField myHeapSizeField; + private JTextField mySharedVMOptionsField; private JTextField myVMOptionsField; private JLabel myHeapSizeLabel; + private JLabel mySharedVMOptionsLabel; private JLabel myVMOptionsLabel; private JCheckBox myCbRebuildOnDependencyChange; private JLabel myResourcePatternsLabel; @@ -85,6 +89,11 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura )); myPatternLegendLabel.setForeground(new JBColor(Gray._50, Gray._130)); tweakControls(project); + myVMOptionsField.getDocument().addDocumentListener(new DocumentAdapter() { + protected void textChanged(DocumentEvent e) { + mySharedVMOptionsField.setEnabled(e.getDocument().getLength() == 0); + } + }); } private void tweakControls(@NotNull Project project) { @@ -125,7 +134,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura ContainerUtilRt.newArrayList(myCbParallelCompilation, myParallelCompilationLegendLabel)); controls.put(Setting.REBUILD_MODULE_ON_DEPENDENCY_CHANGE, ContainerUtilRt.newArrayList(myCbRebuildOnDependencyChange)); controls.put(Setting.HEAP_SIZE, ContainerUtilRt.newArrayList(myHeapSizeLabel, myHeapSizeField)); - controls.put(Setting.COMPILER_VM_OPTIONS, ContainerUtilRt.newArrayList(myVMOptionsLabel, myVMOptionsField)); + controls.put(Setting.COMPILER_VM_OPTIONS, ContainerUtilRt.newArrayList(myVMOptionsLabel, myVMOptionsField, mySharedVMOptionsLabel, mySharedVMOptionsField)); for (Setting setting : myDisabledSettings) { Collection components = controls.get(setting); @@ -149,9 +158,10 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura myCbParallelCompilation.setSelected(workspaceConfiguration.PARALLEL_COMPILATION); myCbRebuildOnDependencyChange.setSelected(workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE); final int javacPreferred = JavacConfiguration.getOptions(myProject, JavacConfiguration.class).MAXIMUM_HEAP_SIZE; // for compatibility with older projects - myHeapSizeField.setText(String.valueOf(workspaceConfiguration.getProcessHeapSize(javacPreferred))); + myHeapSizeField.setText(String.valueOf(configuration.getBuildProcessHeapSize(javacPreferred))); final String options = workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS; myVMOptionsField.setText(options == null ? "" : options.trim()); + mySharedVMOptionsField.setText(configuration.getBuildProcessVMOptions()); configuration.convertPatterns(); @@ -202,7 +212,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura } if (!myDisabledSettings.contains(Setting.HEAP_SIZE)) { try { - workspaceConfiguration.COMPILER_PROCESS_HEAP_SIZE = Integer.parseInt(myHeapSizeField.getText().trim()); + configuration.setBuildProcessHeapSize(Integer.parseInt(myHeapSizeField.getText().trim())); } catch (NumberFormatException ignored) { LOG.info(ignored); @@ -210,6 +220,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura } if (!myDisabledSettings.contains(Setting.COMPILER_VM_OPTIONS)) { workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS = myVMOptionsField.getText().trim(); + configuration.setBuildProcessVMOptions(mySharedVMOptionsField.getText().trim()); } } @@ -268,12 +279,14 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura && ComparingUtils.isModified(myCbParallelCompilation, workspaceConfiguration.PARALLEL_COMPILATION); isModified |= !myDisabledSettings.contains(Setting.REBUILD_MODULE_ON_DEPENDENCY_CHANGE) && ComparingUtils.isModified(myCbRebuildOnDependencyChange, workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE); - isModified |= !myDisabledSettings.contains(Setting.HEAP_SIZE) - && ComparingUtils.isModified(myHeapSizeField, workspaceConfiguration.COMPILER_PROCESS_HEAP_SIZE); isModified |= !myDisabledSettings.contains(Setting.COMPILER_VM_OPTIONS) && ComparingUtils.isModified(myVMOptionsField, workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS); final CompilerConfigurationImpl compilerConfiguration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject); + isModified |= !myDisabledSettings.contains(Setting.HEAP_SIZE) + && ComparingUtils.isModified(myHeapSizeField, compilerConfiguration.getBuildProcessHeapSize(0)); + isModified |= !myDisabledSettings.contains(Setting.COMPILER_VM_OPTIONS) + && ComparingUtils.isModified(mySharedVMOptionsField, compilerConfiguration.getBuildProcessVMOptions()); isModified |= !myDisabledSettings.contains(Setting.ADD_NOT_NULL_ASSERTIONS) && ComparingUtils.isModified(myCbAssertNotNull, compilerConfiguration.isAddNotNullAssertions()); isModified |= !myDisabledSettings.contains(Setting.CLEAR_OUTPUT_DIR_ON_REBUILD) diff --git a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java index 1b38b6fbbd11..7a1c038e789d 100644 --- a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java +++ b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java @@ -16,6 +16,7 @@ package com.intellij.compiler.server; import com.intellij.ProjectTopics; +import com.intellij.compiler.CompilerConfiguration; import com.intellij.compiler.CompilerWorkspaceConfiguration; import com.intellij.compiler.impl.CompilerUtil; import com.intellij.compiler.impl.javaCompiler.javac.JavacConfiguration; @@ -108,7 +109,8 @@ import org.jetbrains.jps.incremental.Utils; import org.jetbrains.jps.model.serialization.JpsGlobalLoader; import javax.swing.*; -import javax.tools.*; +import javax.tools.JavaCompiler; +import javax.tools.ToolProvider; import java.awt.*; import java.io.File; import java.io.FileFilter; @@ -1016,12 +1018,13 @@ public class BuildManager implements ApplicationComponent{ vmExecutablePath = new File(forcedCompiledJdkHome, "bin/java").getAbsolutePath(); } + final CompilerConfiguration projectConfig = CompilerConfiguration.getInstance(project); final CompilerWorkspaceConfiguration config = CompilerWorkspaceConfiguration.getInstance(project); final GeneralCommandLine cmdLine = new GeneralCommandLine(); cmdLine.setExePath(vmExecutablePath); //cmdLine.addParameter("-XX:MaxPermSize=150m"); //cmdLine.addParameter("-XX:ReservedCodeCacheSize=64m"); - final int heapSize = config.getProcessHeapSize(JavacConfiguration.getOptions(project, JavacConfiguration.class).MAXIMUM_HEAP_SIZE); + final int heapSize = projectConfig.getBuildProcessHeapSize(JavacConfiguration.getOptions(project, JavacConfiguration.class).MAXIMUM_HEAP_SIZE); cmdLine.addParameter("-Xmx" + heapSize + "m"); @@ -1060,8 +1063,9 @@ public class BuildManager implements ApplicationComponent{ cmdLine.addParameter("-Dio.netty.initialSeedUniquifier=" + ThreadLocalRandom.getInitialSeedUniquifier()); boolean isProfilingMode = false; - final String additionalOptions = config.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS; - if (!StringUtil.isEmpty(additionalOptions)) { + final String userAdditionalVMOptions = config.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS; + final String additionalOptions = !StringUtil.isEmptyOrSpaces(userAdditionalVMOptions)? userAdditionalVMOptions : projectConfig.getBuildProcessVMOptions(); + if (!StringUtil.isEmptyOrSpaces(additionalOptions)) { final StringTokenizer tokenizer = new StringTokenizer(additionalOptions, " ", false); while (tokenizer.hasMoreTokens()) { final String option = tokenizer.nextToken(); diff --git a/java/compiler/openapi/src/com/intellij/compiler/CompilerConfiguration.java b/java/compiler/openapi/src/com/intellij/compiler/CompilerConfiguration.java index 602c47185b10..6b3a061562a3 100644 --- a/java/compiler/openapi/src/com/intellij/compiler/CompilerConfiguration.java +++ b/java/compiler/openapi/src/com/intellij/compiler/CompilerConfiguration.java @@ -27,6 +27,12 @@ public abstract class CompilerConfiguration { /** @deprecated to be removed in IDEA 16 */ @SuppressWarnings("unused") public static final boolean MAKE_ENABLED = true; + public abstract int getBuildProcessHeapSize(final int javacPreferredHeapSize); + public abstract void setBuildProcessHeapSize(int size); + + public abstract String getBuildProcessVMOptions(); + public abstract void setBuildProcessVMOptions(String options); + @Nullable public abstract String getProjectBytecodeTarget(); diff --git a/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java b/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java index 40db69f79f04..22fd6c6527ef 100644 --- a/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java +++ b/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java @@ -34,8 +34,6 @@ import com.intellij.util.xmlb.XmlSerializerUtil; public class CompilerWorkspaceConfiguration implements PersistentStateComponent { private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.CompilerWorkspaceConfiguration"); - public static final int DEFAULT_COMPILE_PROCESS_HEAP_SIZE = 700; - public static final String DEFAULT_COMPILE_PROCESS_VM_OPTIONS = ""; static { LOG.info("Available processors: " + Runtime.getRuntime().availableProcessors()); } @@ -46,8 +44,7 @@ public class CompilerWorkspaceConfiguration implements PersistentStateComponent< public boolean CLEAR_OUTPUT_DIRECTORY = true; public boolean MAKE_PROJECT_ON_SAVE = false; // until we fix problems with several open projects (IDEA-104064), daemon slowness (IDEA-104666) public boolean PARALLEL_COMPILATION = false; - public int COMPILER_PROCESS_HEAP_SIZE = DEFAULT_COMPILE_PROCESS_HEAP_SIZE; - public String COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS = DEFAULT_COMPILE_PROCESS_VM_OPTIONS; + public String COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS = ""; public boolean REBUILD_ON_DEPENDENCY_CHANGE = true; public static CompilerWorkspaceConfiguration getInstance(Project project) { @@ -65,13 +62,4 @@ public class CompilerWorkspaceConfiguration implements PersistentStateComponent< public boolean allowAutoMakeWhileRunningApplication() { return false;/*ALLOW_AUTOMAKE_WHILE_RUNNING_APPLICATION*/ } - - public int getProcessHeapSize(final int javacPreferredHeapSize) { - final int heapSize = COMPILER_PROCESS_HEAP_SIZE; - if (heapSize != DEFAULT_COMPILE_PROCESS_HEAP_SIZE) { - return heapSize; - } - // compatibility with older builds: if javac is set to use larger heap, and if so, use it. - return Math.max(heapSize, javacPreferredHeapSize); - } }