From 414025cbc1ce3609d18b59f258074eb2b0bebc02 Mon Sep 17 00:00:00 2001 From: Rustam Vishnyakov Date: Thu, 10 Aug 2017 13:28:49 +0300 Subject: [PATCH] Migration to new project code style setttings, merged changes --- .../CodeStyleGenerationConfigurable.java | 118 ++++--- .../options/JavaCodeStyleImportsPanel.java | 12 +- .../options/JavaDocFormattingPanel.java | 8 +- .../ExternalAnnotationsManagerImpl.java | 9 +- .../codeInsight/MakeAnnotationExternal.java | 3 +- ...reateConstructorParameterFromFieldFix.java | 6 +- .../impl/quickfix/CreateFromUsageBaseFix.java | 3 +- .../quickfix/CreateLocalFromUsageFix.java | 4 +- ...atorForEachLoopWithIteratorForLoopFix.java | 7 +- .../VariableAccessFromInnerClassFix.java | 3 +- .../generation/GenerateEqualsHelper.java | 4 +- .../generation/GenerateMembersUtil.java | 7 +- .../generation/OverrideImplementUtil.java | 22 +- ...rrideImplementsAnnotationsHandlerImpl.java | 3 +- .../impl/BindFieldsFromParametersAction.java | 2 +- ...JavaLanguageCodeStyleSettingsProvider.java | 3 +- ...EnterInJavadocParamDescriptionHandler.java | 4 +- .../com/intellij/javadoc/JavadocHelper.java | 3 +- .../lang/java/JavaDocumentationProvider.java | 10 +- .../psi/codeStyle/JavaCodeStyleSettings.java | 305 +++++++++++++++- .../JavaCodeStyleSettingsFacadeImpl.java | 10 +- .../codeStyle/FormatCommentsProcessor.java | 3 +- .../impl/source/codeStyle/ImportHelper.java | 15 +- .../codeStyle/JavaCodeStyleManagerImpl.java | 31 +- .../codeStyle/JavaReferenceAdjuster.java | 6 +- .../codeStyle/javadoc/CommentFormatter.java | 6 +- .../source/codeStyle/javadoc/JDComment.java | 2 +- .../source/codeStyle/javadoc/JDParser.java | 9 +- .../JavaChangeSignatureUsageProcessor.java | 10 +- .../extractMethod/ExtractMethodProcessor.java | 4 +- .../ExtractMethodObjectProcessor.java | 7 +- .../extractclass/ExtractClassProcessor.java | 7 +- ...InlineToAnonymousConstructorProcessor.java | 4 +- .../InplaceIntroduceParameterUI.java | 5 +- .../IntroduceParameterDialog.java | 4 +- .../IntroduceVariableBase.java | 9 +- .../IntroduceVariableDialog.java | 3 +- .../ParameterObjectBuilder.java | 5 +- .../makeStatic/MakeClassStaticProcessor.java | 8 +- .../JavaMoveClassToInnerHandler.java | 3 +- .../ReturnValueBeanBuilder.java | 5 +- .../codeInsight/AddAnnotationFixTest.java | 5 +- .../codeInsight/ExternalAnnotationsTest.java | 5 +- .../codeInsight/GenerateConstructorTest.java | 10 +- .../codeInsight/GenerateEqualsTestCase.java | 5 +- .../GenerateGetterSetterTest.groovy | 3 +- .../codeInsight/OverrideImplement15Test.java | 7 +- .../codeInsight/SuppressExternalTest.java | 8 +- .../completion/NormalCompletionTest.groovy | 5 +- .../completion/SmartTypeCompletionTest.java | 9 +- .../completion/VariablesCompletionTest.groovy | 11 +- .../codeInsight/daemon/ImportHelperTest.java | 16 +- .../AssignFieldFromParameterTest.java | 5 +- .../BindFieldsFromParametersTest.java | 6 +- ...eateConstructorParameterFromFieldTest.java | 6 +- .../CreateFieldFromParameterTest.java | 5 +- .../quickFix/CreateLocalFromUsageTest.java | 6 +- .../Lambda2MethodReferenceInspectionTest.java | 12 +- ...ForEachLoopWithIteratorForLoopFixTest.java | 6 +- .../AddSingleStaticImportActionTest.java | 4 +- .../CopyAbstractMethodImplementationTest.java | 3 +- .../templates/ForeachTemplateTest.java | 4 +- .../psi/formatter/java/JavaFormatterTest.java | 8 +- .../formatter/java/JavadocFormatterTest.java | 114 +++--- .../tree/java/BindToGenericClassTest.java | 7 +- ...ethodObjectWithMultipleExitPointsTest.java | 4 +- .../java/refactoring/ExtractMethodTest.java | 9 +- .../InplaceIntroduceVariableTest.java | 4 +- .../java/refactoring/MakeClassStaticTest.java | 4 +- .../refactoring/MoveClassToInnerTest.java | 8 +- .../ConvertFieldToAtomicIntention.java | 3 +- .../testSrc/CodeStyleTest.kt | 24 +- .../psi/codeStyle/CodeStyleScheme.java | 3 + .../psi/codeStyle/CodeStyleSettings.java | 330 +++++++++++++----- .../codeStyle/CodeStyleSettingsManager.java | 42 ++- .../codeStyle/CommonCodeStyleSettings.java | 2 + .../codeStyle/CustomCodeStyleSettings.java | 3 +- .../LegacyCodeStyleSettingsManager.java | 4 +- .../ProjectCodeStyleSettingsManager.java | 125 ++++++- .../codeStyle/CodeStyleSchemesModel.java | 4 +- .../editorActions/CodeDocumentationUtil.java | 20 +- .../editorActions/EnterHandler.java | 2 +- .../enter/EnterAfterJavadocTagHandler.java | 6 +- .../enter/EnterBetweenBracesHandler.java | 5 +- .../QuickChangeCodeStyleSchemeAction.java | 2 +- .../source/codeStyle/CodeStyleSchemeImpl.java | 4 +- .../migrateChanged.xml | 10 + .../migrateDefault.xml | 4 + .../CodeStyleConfigurationTest.java | 1 + .../codeStyleSettings/CodeStyleTestCase.java | 30 ++ .../CodeStyleXmlImporterTest.java | 10 +- .../NewProjectSettingsTest.java | 76 ++++ .../ProjectCodeStyleMigrationTest.java | 92 +++++ .../psi/formatter/FormatterTestCase.java | 1 - .../LambdaCanBeMethodReferenceInspection.java | 9 +- .../inheritance/RefusedBequestInspection.java | 2 +- .../EnumerationCanBeIterationInspection.java | 2 +- .../migration/ForCanBeForeachInspection.java | 6 +- .../WhileCanBeForeachInspection.java | 3 +- ...ngBufferReplaceableByStringInspection.java | 4 +- ...necessaryFullyQualifiedNameInspection.java | 2 +- ...elyNamedBooleanVariableInspectionTest.java | 3 +- .../SuspiciousGetterSetterInspectionTest.java | 5 +- .../adapter/AdapterToListenerIntention.java | 5 +- ...akeCallChainIntoCallSequenceIntention.java | 5 +- ...orEachLoopWithIndexedForLoopIntention.java | 2 +- ...rEachLoopWithIteratorForLoopIntention.java | 3 +- .../fqnames/FullyQualifiedNamePredicate.java | 3 +- ...ataPointHolderConversionIntentionTest.java | 6 +- .../EclipseCodeStyleImportWorker.java | 29 +- .../eclipse/importer/EclipseImportMap.java | 22 ++ .../importer/EclipseImportMap.properties | 2 +- .../eclipse/EclipseSettingsImportTest.java | 10 +- .../java/generate/GenerationUtil.java | 3 +- .../generate/element/GenerationHelper.java | 6 +- ...GroovyCodeStyleGenerationConfigurable.java | 28 +- .../codeStyle/GroovyCodeStyleSettings.java | 22 +- .../GroovyCodeStyleSettingsFacadeImpl.java | 14 +- .../GroovyDocumentationProvider.java | 4 +- .../javaFX/fxml/JavaFXQuickfixTest.java | 4 +- ...UnresolvedFxIdReferenceInspectionTest.java | 4 +- .../JavaFxEventHandlerInspectionTest.java | 4 +- .../codeInsight/JavaFxImportsOptimizer.java | 4 +- ...vaFxUnresolvedFxIdReferenceInspection.java | 4 +- .../refs/JavaFxEventHandlerReference.java | 7 +- .../introduce/IntroducePropertyDialog.java | 6 +- .../formatter/xml/XmlCodeStyleSettings.java | 36 -- 127 files changed, 1492 insertions(+), 571 deletions(-) create mode 100644 platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateChanged.xml create mode 100644 platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateDefault.xml create mode 100644 platform/platform-tests/testSrc/com/intellij/ide/codeStyleSettings/NewProjectSettingsTest.java create mode 100644 platform/platform-tests/testSrc/com/intellij/ide/codeStyleSettings/ProjectCodeStyleMigrationTest.java diff --git a/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java b/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java index a85fdc186367..fced29473dd7 100644 --- a/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java +++ b/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java @@ -28,6 +28,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiClass; import com.intellij.psi.codeStyle.CodeStyleConfigurable; import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.refactoring.RefactoringBundle; import com.intellij.refactoring.ui.JavaVisibilityPanel; import com.intellij.ui.SortedListModel; @@ -101,32 +102,33 @@ public class CodeStyleGenerationConfigurable implements CodeStyleConfigurable { } public void reset(@NotNull CodeStyleSettings settings) { - myCbPreferLongerNames.setSelected(settings.PREFER_LONGER_NAMES); + JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); + myCbPreferLongerNames.setSelected(javaSettings.PREFER_LONGER_NAMES); - myFieldPrefixField.setText(settings.FIELD_NAME_PREFIX); - myStaticFieldPrefixField.setText(settings.STATIC_FIELD_NAME_PREFIX); - myParameterPrefixField.setText(settings.PARAMETER_NAME_PREFIX); - myLocalVariablePrefixField.setText(settings.LOCAL_VARIABLE_NAME_PREFIX); + myFieldPrefixField.setText(javaSettings.FIELD_NAME_PREFIX); + myStaticFieldPrefixField.setText(javaSettings.STATIC_FIELD_NAME_PREFIX); + myParameterPrefixField.setText(javaSettings.PARAMETER_NAME_PREFIX); + myLocalVariablePrefixField.setText(javaSettings.LOCAL_VARIABLE_NAME_PREFIX); - myFieldSuffixField.setText(settings.FIELD_NAME_SUFFIX); - myStaticFieldSuffixField.setText(settings.STATIC_FIELD_NAME_SUFFIX); - myParameterSuffixField.setText(settings.PARAMETER_NAME_SUFFIX); - myLocalVariableSuffixField.setText(settings.LOCAL_VARIABLE_NAME_SUFFIX); + myFieldSuffixField.setText(javaSettings.FIELD_NAME_SUFFIX); + myStaticFieldSuffixField.setText(javaSettings.STATIC_FIELD_NAME_SUFFIX); + myParameterSuffixField.setText(javaSettings.PARAMETER_NAME_SUFFIX); + myLocalVariableSuffixField.setText(javaSettings.LOCAL_VARIABLE_NAME_SUFFIX); - myCbGenerateFinalLocals.setSelected(settings.GENERATE_FINAL_LOCALS); - myCbGenerateFinalParameters.setSelected(settings.GENERATE_FINAL_PARAMETERS); + myCbGenerateFinalLocals.setSelected(javaSettings.GENERATE_FINAL_LOCALS); + myCbGenerateFinalParameters.setSelected(javaSettings.GENERATE_FINAL_PARAMETERS); - myCbUseExternalAnnotations.setSelected(settings.USE_EXTERNAL_ANNOTATIONS); - myInsertOverrideAnnotationCheckBox.setSelected(settings.INSERT_OVERRIDE_ANNOTATION); - myRepeatSynchronizedCheckBox.setSelected(settings.REPEAT_SYNCHRONIZED); - myJavaVisibilityPanel.setVisibility(settings.VISIBILITY); + myCbUseExternalAnnotations.setSelected(javaSettings.USE_EXTERNAL_ANNOTATIONS); + myInsertOverrideAnnotationCheckBox.setSelected(javaSettings.INSERT_OVERRIDE_ANNOTATION); + myRepeatSynchronizedCheckBox.setSelected(javaSettings.REPEAT_SYNCHRONIZED); + myJavaVisibilityPanel.setVisibility(javaSettings.VISIBILITY); - myReplaceCastCb.setSelected(settings.REPLACE_CAST); - myReplaceInstanceOfCb.setSelected(settings.REPLACE_INSTANCEOF); - myReplaceNullCheckCb.setSelected(settings.REPLACE_NULL_CHECK); + myReplaceCastCb.setSelected(javaSettings.REPLACE_CAST); + myReplaceInstanceOfCb.setSelected(javaSettings.REPLACE_INSTANCEOF); + myReplaceNullCheckCb.setSelected(javaSettings.REPLACE_NULL_CHECK); myRepeatAnnotationsModel.clear(); - myRepeatAnnotationsModel.addAll(settings.getRepeatAnnotations()); + myRepeatAnnotationsModel.addAll(javaSettings.getRepeatAnnotations()); myCommenterForm.reset(settings); } @@ -135,34 +137,35 @@ public class CodeStyleGenerationConfigurable implements CodeStyleConfigurable { } public void apply(@NotNull CodeStyleSettings settings) throws ConfigurationException { - settings.PREFER_LONGER_NAMES = myCbPreferLongerNames.isSelected(); + JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); + javaSettings.PREFER_LONGER_NAMES = myCbPreferLongerNames.isSelected(); - settings.FIELD_NAME_PREFIX = setPrefixSuffix(myFieldPrefixField.getText(), true); - settings.STATIC_FIELD_NAME_PREFIX = setPrefixSuffix(myStaticFieldPrefixField.getText(), true); - settings.PARAMETER_NAME_PREFIX = setPrefixSuffix(myParameterPrefixField.getText(), true); - settings.LOCAL_VARIABLE_NAME_PREFIX = setPrefixSuffix(myLocalVariablePrefixField.getText(), true); + javaSettings.FIELD_NAME_PREFIX = setPrefixSuffix(myFieldPrefixField.getText(), true); + javaSettings.STATIC_FIELD_NAME_PREFIX = setPrefixSuffix(myStaticFieldPrefixField.getText(), true); + javaSettings.PARAMETER_NAME_PREFIX = setPrefixSuffix(myParameterPrefixField.getText(), true); + javaSettings.LOCAL_VARIABLE_NAME_PREFIX = setPrefixSuffix(myLocalVariablePrefixField.getText(), true); - settings.FIELD_NAME_SUFFIX = setPrefixSuffix(myFieldSuffixField.getText(), false); - settings.STATIC_FIELD_NAME_SUFFIX = setPrefixSuffix(myStaticFieldSuffixField.getText(), false); - settings.PARAMETER_NAME_SUFFIX = setPrefixSuffix(myParameterSuffixField.getText(), false); - settings.LOCAL_VARIABLE_NAME_SUFFIX = setPrefixSuffix(myLocalVariableSuffixField.getText(), false); + javaSettings.FIELD_NAME_SUFFIX = setPrefixSuffix(myFieldSuffixField.getText(), false); + javaSettings.STATIC_FIELD_NAME_SUFFIX = setPrefixSuffix(myStaticFieldSuffixField.getText(), false); + javaSettings.PARAMETER_NAME_SUFFIX = setPrefixSuffix(myParameterSuffixField.getText(), false); + javaSettings.LOCAL_VARIABLE_NAME_SUFFIX = setPrefixSuffix(myLocalVariableSuffixField.getText(), false); - settings.GENERATE_FINAL_LOCALS = myCbGenerateFinalLocals.isSelected(); - settings.GENERATE_FINAL_PARAMETERS = myCbGenerateFinalParameters.isSelected(); + javaSettings.GENERATE_FINAL_LOCALS = myCbGenerateFinalLocals.isSelected(); + javaSettings.GENERATE_FINAL_PARAMETERS = myCbGenerateFinalParameters.isSelected(); - settings.USE_EXTERNAL_ANNOTATIONS = myCbUseExternalAnnotations.isSelected(); - settings.INSERT_OVERRIDE_ANNOTATION = myInsertOverrideAnnotationCheckBox.isSelected(); - settings.REPEAT_SYNCHRONIZED = myRepeatSynchronizedCheckBox.isSelected(); + javaSettings.USE_EXTERNAL_ANNOTATIONS = myCbUseExternalAnnotations.isSelected(); + javaSettings.INSERT_OVERRIDE_ANNOTATION = myInsertOverrideAnnotationCheckBox.isSelected(); + javaSettings.REPEAT_SYNCHRONIZED = myRepeatSynchronizedCheckBox.isSelected(); - settings.VISIBILITY = myJavaVisibilityPanel.getVisibility(); + javaSettings.VISIBILITY = myJavaVisibilityPanel.getVisibility(); - settings.REPLACE_CAST = myReplaceCastCb.isSelected(); - settings.REPLACE_INSTANCEOF = myReplaceInstanceOfCb.isSelected(); - settings.REPLACE_NULL_CHECK = myReplaceNullCheckCb.isSelected(); + javaSettings.REPLACE_CAST = myReplaceCastCb.isSelected(); + javaSettings.REPLACE_INSTANCEOF = myReplaceInstanceOfCb.isSelected(); + javaSettings.REPLACE_NULL_CHECK = myReplaceNullCheckCb.isSelected(); myCommenterForm.apply(settings); - settings.setRepeatAnnotations(myRepeatAnnotationsModel.getItems()); + javaSettings.setRepeatAnnotations(myRepeatAnnotationsModel.getItems()); for (Project project : ProjectManager.getInstance().getOpenProjects()) { DaemonCodeAnalyzer.getInstance(project).settingsChanged(); @@ -183,34 +186,35 @@ public class CodeStyleGenerationConfigurable implements CodeStyleConfigurable { } public boolean isModified(CodeStyleSettings settings) { - boolean isModified = isModified(myCbPreferLongerNames, settings.PREFER_LONGER_NAMES); + JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); + boolean isModified = isModified(myCbPreferLongerNames, javaSettings.PREFER_LONGER_NAMES); - isModified |= isModified(myFieldPrefixField, settings.FIELD_NAME_PREFIX); - isModified |= isModified(myStaticFieldPrefixField, settings.STATIC_FIELD_NAME_PREFIX); - isModified |= isModified(myParameterPrefixField, settings.PARAMETER_NAME_PREFIX); - isModified |= isModified(myLocalVariablePrefixField, settings.LOCAL_VARIABLE_NAME_PREFIX); + isModified |= isModified(myFieldPrefixField, javaSettings.FIELD_NAME_PREFIX); + isModified |= isModified(myStaticFieldPrefixField, javaSettings.STATIC_FIELD_NAME_PREFIX); + isModified |= isModified(myParameterPrefixField, javaSettings.PARAMETER_NAME_PREFIX); + isModified |= isModified(myLocalVariablePrefixField, javaSettings.LOCAL_VARIABLE_NAME_PREFIX); - isModified |= isModified(myFieldSuffixField, settings.FIELD_NAME_SUFFIX); - isModified |= isModified(myStaticFieldSuffixField, settings.STATIC_FIELD_NAME_SUFFIX); - isModified |= isModified(myParameterSuffixField, settings.PARAMETER_NAME_SUFFIX); - isModified |= isModified(myLocalVariableSuffixField, settings.LOCAL_VARIABLE_NAME_SUFFIX); + isModified |= isModified(myFieldSuffixField, javaSettings.FIELD_NAME_SUFFIX); + isModified |= isModified(myStaticFieldSuffixField, javaSettings.STATIC_FIELD_NAME_SUFFIX); + isModified |= isModified(myParameterSuffixField, javaSettings.PARAMETER_NAME_SUFFIX); + isModified |= isModified(myLocalVariableSuffixField, javaSettings.LOCAL_VARIABLE_NAME_SUFFIX); - isModified |= isModified(myCbGenerateFinalLocals, settings.GENERATE_FINAL_LOCALS); - isModified |= isModified(myCbGenerateFinalParameters, settings.GENERATE_FINAL_PARAMETERS); + isModified |= isModified(myCbGenerateFinalLocals, javaSettings.GENERATE_FINAL_LOCALS); + isModified |= isModified(myCbGenerateFinalParameters, javaSettings.GENERATE_FINAL_PARAMETERS); - isModified |= isModified(myCbUseExternalAnnotations, settings.USE_EXTERNAL_ANNOTATIONS); - isModified |= isModified(myInsertOverrideAnnotationCheckBox, settings.INSERT_OVERRIDE_ANNOTATION); - isModified |= isModified(myRepeatSynchronizedCheckBox, settings.REPEAT_SYNCHRONIZED); + isModified |= isModified(myCbUseExternalAnnotations, javaSettings.USE_EXTERNAL_ANNOTATIONS); + isModified |= isModified(myInsertOverrideAnnotationCheckBox, javaSettings.INSERT_OVERRIDE_ANNOTATION); + isModified |= isModified(myRepeatSynchronizedCheckBox, javaSettings.REPEAT_SYNCHRONIZED); - isModified |= isModified(myReplaceCastCb, settings.REPLACE_CAST); - isModified |= isModified(myReplaceInstanceOfCb, settings.REPLACE_INSTANCEOF); - isModified |= isModified(myReplaceNullCheckCb, settings.REPLACE_NULL_CHECK); + isModified |= isModified(myReplaceCastCb, javaSettings.REPLACE_CAST); + isModified |= isModified(myReplaceInstanceOfCb, javaSettings.REPLACE_INSTANCEOF); + isModified |= isModified(myReplaceNullCheckCb, javaSettings.REPLACE_NULL_CHECK); - isModified |= !settings.VISIBILITY.equals(myJavaVisibilityPanel.getVisibility()); + isModified |= !javaSettings.VISIBILITY.equals(myJavaVisibilityPanel.getVisibility()); isModified |= myCommenterForm.isModified(settings); - isModified |= !myRepeatAnnotationsModel.getItems().equals(settings.getRepeatAnnotations()); + isModified |= !myRepeatAnnotationsModel.getItems().equals(javaSettings.getRepeatAnnotations()); return isModified; } diff --git a/java/java-impl/src/com/intellij/application/options/JavaCodeStyleImportsPanel.java b/java/java-impl/src/com/intellij/application/options/JavaCodeStyleImportsPanel.java index c8739cc8fa3f..53f655b86799 100644 --- a/java/java-impl/src/com/intellij/application/options/JavaCodeStyleImportsPanel.java +++ b/java/java-impl/src/com/intellij/application/options/JavaCodeStyleImportsPanel.java @@ -16,7 +16,9 @@ package com.intellij.application.options; import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.ui.OptionGroup; +import org.jetbrains.annotations.NotNull; class JavaCodeStyleImportsPanel extends CodeStyleImportsPanelBase { private FullyQualifiedNamesInJavadocOptionProvider myFqnInJavadocOption; @@ -29,19 +31,23 @@ class JavaCodeStyleImportsPanel extends CodeStyleImportsPanelBase { @Override public void apply(CodeStyleSettings settings) { - applyLayoutSettings(settings); + applyLayoutSettings(getJavaSettings(settings)); myFqnInJavadocOption.apply(settings); } @Override public void reset(CodeStyleSettings settings) { - resetLayoutSettings(settings); + resetLayoutSettings(getJavaSettings(settings)); myFqnInJavadocOption.reset(settings); } @Override public boolean isModified(CodeStyleSettings settings) { - return isModifiedLayoutSettings(settings) || myFqnInJavadocOption.isModified(settings); + return isModifiedLayoutSettings(getJavaSettings(settings)) || myFqnInJavadocOption.isModified(settings); + } + + private static JavaCodeStyleSettings getJavaSettings(@NotNull CodeStyleSettings settings) { + return settings.getCustomSettings(JavaCodeStyleSettings.class); } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/application/options/JavaDocFormattingPanel.java b/java/java-impl/src/com/intellij/application/options/JavaDocFormattingPanel.java index 8ef4cb58677f..6fabb0531a30 100644 --- a/java/java-impl/src/com/intellij/application/options/JavaDocFormattingPanel.java +++ b/java/java-impl/src/com/intellij/application/options/JavaDocFormattingPanel.java @@ -22,6 +22,7 @@ import com.intellij.openapi.fileTypes.FileType; import com.intellij.openapi.fileTypes.StdFileTypes; import com.intellij.openapi.ui.OnePixelDivider; import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.codeStyle.LanguageCodeStyleSettingsProvider; import com.intellij.ui.border.CustomLineBorder; import org.jetbrains.annotations.NotNull; @@ -152,17 +153,18 @@ public class JavaDocFormattingPanel extends OptionTreeWithPreviewPanel { public void apply(CodeStyleSettings settings) { super.apply(settings); - settings.ENABLE_JAVADOC_FORMATTING = myEnableCheckBox.isSelected(); + settings.getCustomSettings(JavaCodeStyleSettings.class).ENABLE_JAVADOC_FORMATTING = myEnableCheckBox.isSelected(); } protected void resetImpl(final CodeStyleSettings settings) { super.resetImpl(settings); - myEnableCheckBox.setSelected(settings.ENABLE_JAVADOC_FORMATTING); + myEnableCheckBox.setSelected(settings.getCustomSettings(JavaCodeStyleSettings.class).ENABLE_JAVADOC_FORMATTING); update(); } public boolean isModified(CodeStyleSettings settings) { - return super.isModified(settings) || myEnableCheckBox.isSelected() != settings.ENABLE_JAVADOC_FORMATTING; + return super.isModified(settings) || + myEnableCheckBox.isSelected() != settings.getCustomSettings(JavaCodeStyleSettings.class).ENABLE_JAVADOC_FORMATTING; } @NotNull diff --git a/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java b/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java index cb4c352a1029..0b2100e10fbf 100644 --- a/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java @@ -62,6 +62,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.*; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.xml.XmlDocument; import com.intellij.psi.xml.XmlFile; import com.intellij.psi.xml.XmlTag; @@ -488,7 +489,7 @@ public class ExternalAnnotationsManagerImpl extends ReadableExternalAnnotationsM //choose external place iff USE_EXTERNAL_ANNOTATIONS option is on, //otherwise external annotations should be read-only - if (CodeStyleSettingsManager.getSettings(project).USE_EXTERNAL_ANNOTATIONS) { + if (CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS) { final PsiFile containingFile = element.getContainingFile(); final VirtualFile virtualFile = containingFile.getVirtualFile(); LOG.assertTrue(virtualFile != null); @@ -760,7 +761,7 @@ public class ExternalAnnotationsManagerImpl extends ReadableExternalAnnotationsM public static boolean areExternalAnnotationsApplicable(@NotNull PsiModifierListOwner owner) { if (!owner.isPhysical()) return false; if (!owner.getManager().isInProject(owner)) return true; - return CodeStyleSettingsManager.getSettings(owner.getProject()).USE_EXTERNAL_ANNOTATIONS; + return CodeStyleSettingsManager.getSettings(owner.getProject()).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS; } private static class MyExternalPromptDialog extends OptionsMessageDialog { @@ -809,12 +810,12 @@ public class ExternalAnnotationsManagerImpl extends ReadableExternalAnnotationsM @Override protected boolean isToBeShown() { - return CodeStyleSettingsManager.getSettings(myProject).USE_EXTERNAL_ANNOTATIONS; + return CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS; } @Override protected void setToBeShown(boolean value, boolean onOk) { - CodeStyleSettingsManager.getSettings(myProject).USE_EXTERNAL_ANNOTATIONS = value; + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS = value; } @Override diff --git a/java/java-impl/src/com/intellij/codeInsight/MakeAnnotationExternal.java b/java/java-impl/src/com/intellij/codeInsight/MakeAnnotationExternal.java index a7dc0bef3c53..dd4137de165f 100644 --- a/java/java-impl/src/com/intellij/codeInsight/MakeAnnotationExternal.java +++ b/java/java-impl/src/com/intellij/codeInsight/MakeAnnotationExternal.java @@ -25,6 +25,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiModifierListOwner; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.IncorrectOperationException; @@ -49,7 +50,7 @@ public class MakeAnnotationExternal extends BaseIntentionAction { PsiModifierListOwner modifierListOwner = PsiTreeUtil.getParentOfType(annotation, PsiModifierListOwner.class); if (modifierListOwner != null) { VirtualFile virtualFile = PsiUtilCore.getVirtualFile(modifierListOwner); - if (CodeStyleSettingsManager.getSettings(project).USE_EXTERNAL_ANNOTATIONS || + if (CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS || virtualFile != null && ExternalAnnotationsManager.getInstance(project).hasAnnotationRootsForFile(virtualFile)) { setText("Annotate externally"); return true; diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java index 9558ca390c71..69174dbad596 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java @@ -246,7 +246,7 @@ public class CreateConstructorParameterFromFieldFix implements IntentionAction { types.putValue(param.getType(), param); } - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class); final boolean preferLongerNames = settings.PREFER_LONGER_NAMES; for (PsiVariable param : params) { final PsiType paramType = param.getType(); @@ -296,7 +296,9 @@ public class CreateConstructorParameterFromFieldFix implements IntentionAction { if (isUnique(parameters, newName, usedNames)) { break; } - newName = n < nameInfo.names.length && !CodeStyleSettingsManager.getSettings(variable.getProject()).PREFER_LONGER_NAMES + newName = n < nameInfo.names.length && + !CodeStyleSettingsManager.getSettings( + variable.getProject()).getCustomSettings(JavaCodeStyleSettings.class).PREFER_LONGER_NAMES ? nameInfo.names[n++] : nameInfo.names[0] + n++; } return newName; diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java index 65599ebc2921..5e71a9edc968 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java @@ -37,6 +37,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.PsiUtilCore; @@ -188,7 +189,7 @@ public abstract class CreateFromUsageBaseFix extends BaseIntentionAction { if (parentClass != null && (parentClass.equals(targetClass) || PsiTreeUtil.isAncestor(targetClass, parentClass, true))) { return PsiModifier.PRIVATE; } else { - return CodeStyleSettingsManager.getSettings(targetClass.getProject()).VISIBILITY; + return CodeStyleSettingsManager.getSettings(targetClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).VISIBILITY; } } diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateLocalFromUsageFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateLocalFromUsageFix.java index cdb6522a04d2..b0585b45b6a6 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateLocalFromUsageFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateLocalFromUsageFix.java @@ -29,6 +29,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleManager; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.refactoring.introduceParameter.AbstractJavaInplaceIntroducer; @@ -117,7 +118,8 @@ public class CreateLocalFromUsageFix extends CreateVarFromUsageFix { PsiVariable var = (PsiVariable)decl.getDeclaredElements()[0]; boolean isFinal = - CodeStyleSettingsManager.getSettings(project).GENERATE_FINAL_LOCALS && !CreateFromUsageUtils.isAccessedForWriting(expressions); + CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS && + !CreateFromUsageUtils.isAccessedForWriting(expressions); PsiUtil.setModifierProperty(var, PsiModifier.FINAL, isFinal); var = CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(var); diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ReplaceIteratorForEachLoopWithIteratorForLoopFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ReplaceIteratorForEachLoopWithIteratorForLoopFix.java index 452af53bc584..fe996a041ee5 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ReplaceIteratorForEachLoopWithIteratorForLoopFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ReplaceIteratorForEachLoopWithIteratorForLoopFix.java @@ -19,10 +19,7 @@ import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettings; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.*; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; @@ -101,7 +98,7 @@ public class ReplaceIteratorForEachLoopWithIteratorForLoopFix implements Intenti newItemVariable.getTypeElement().replace(newItemTypeElement); newItemVariable.setName(iterationParameterName); final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(project); - if (codeStyleSettings.GENERATE_FINAL_LOCALS) { + if (codeStyleSettings.getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS) { final PsiModifierList modifierList = newItemVariable.getModifierList(); if (modifierList != null) modifierList.setModifierProperty(PsiModifier.FINAL, true); } diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/VariableAccessFromInnerClassFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/VariableAccessFromInnerClassFix.java index 06b50ce80d31..497f8e33012c 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/VariableAccessFromInnerClassFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/VariableAccessFromInnerClassFix.java @@ -29,6 +29,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.controlFlow.ControlFlowUtil; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; @@ -209,7 +210,7 @@ public class VariableAccessFromInnerClassFix implements IntentionAction { PsiDeclarationStatement copyDecl = factory.createVariableDeclarationStatement(newName, type, initializer); PsiVariable newVariable = (PsiVariable)copyDecl.getDeclaredElements()[0]; final boolean mustBeFinal = - !PsiUtil.isLanguageLevel8OrHigher(context) || CodeStyleSettingsManager.getSettings(project).GENERATE_FINAL_LOCALS; + !PsiUtil.isLanguageLevel8OrHigher(context) || CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS; PsiUtil.setModifierProperty(newVariable, PsiModifier.FINAL, mustBeFinal); PsiElement statement = getStatementToInsertBefore(variable, context); if (statement == null) return; diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateEqualsHelper.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateEqualsHelper.java index 3867a1982879..be0224279ad9 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateEqualsHelper.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateEqualsHelper.java @@ -93,7 +93,7 @@ public class GenerateEqualsHelper implements Runnable { } private static boolean shouldAddOverrideAnnotation(PsiElement context) { - CodeStyleSettings style = CodeStyleSettingsManager.getSettings(context.getProject()); + JavaCodeStyleSettings style = CodeStyleSettingsManager.getSettings(context.getProject()).getCustomSettings(JavaCodeStyleSettings.class); return style.INSERT_OVERRIDE_ANNOTATION && PsiUtil.isLanguageLevel5OrHigher(context); } @@ -169,7 +169,7 @@ public class GenerateEqualsHelper implements Runnable { private PsiMethod createEquals() throws IncorrectOperationException { @NonNls StringBuilder buffer = new StringBuilder(); - CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(myProject); + JavaCodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class); ArrayList equalsFields = new ArrayList<>(); ContainerUtil.addAll(equalsFields, myEqualsFields); Collections.sort(equalsFields, EqualsFieldsComparator.INSTANCE); diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java index c54333d4c1b1..e8a54036eafa 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java @@ -224,7 +224,8 @@ public class GenerateMembersUtil { if (member instanceof PsiMethod) { if (!aClass.isInterface()) { final PsiParameter[] parameters = ((PsiMethod)member).getParameterList().getParameters(); - final boolean generateFinals = CodeStyleSettingsManager.getSettings(aClass.getProject()).GENERATE_FINAL_PARAMETERS; + final boolean generateFinals = CodeStyleSettingsManager.getSettings(aClass.getProject()) + .getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS; for (final PsiParameter parameter : parameters) { PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, generateFinals); } @@ -710,7 +711,7 @@ public class GenerateMembersUtil { public static PsiMethod setVisibility(PsiMember member, PsiMethod prototype) { if (prototype == null) return null; - String visibility = CodeStyleSettingsManager.getSettings(member.getProject()).VISIBILITY; + String visibility = CodeStyleSettingsManager.getSettings(member.getProject()).getCustomSettings(JavaCodeStyleSettings.class).VISIBILITY; @PsiModifier.ModifierConstant String newVisibility; if (VisibilityUtil.ESCALATE_VISIBILITY.equals(visibility)) { @@ -730,7 +731,7 @@ public class GenerateMembersUtil { public static PsiMethod annotateOnOverrideImplement(@Nullable PsiClass targetClass, @Nullable PsiMethod generated) { if (generated == null || targetClass == null) return generated; - if (CodeStyleSettingsManager.getSettings(targetClass.getProject()).INSERT_OVERRIDE_ANNOTATION) { + if (CodeStyleSettingsManager.getSettings(targetClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION) { PsiMethod superMethod = targetClass.findMethodBySignature(generated, true); if (superMethod != null && superMethod.getContainingClass() != targetClass) { OverrideImplementUtil.annotateOnOverrideImplement(generated, targetClass, superMethod, true); diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java index e21623af5b47..b7edef89913d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java @@ -51,10 +51,7 @@ import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.ui.Messages; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.CommonCodeStyleSettings; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.infos.CandidateInfo; import com.intellij.psi.javadoc.PsiDocComment; import com.intellij.psi.util.*; @@ -96,11 +93,12 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil { ? TypeConversionUtil.getSuperClassSubstitutor(containingClass, aClass, PsiSubstitutor.EMPTY) : PsiSubstitutor.EMPTY; return overrideOrImplementMethod(aClass, method, substitutor, toCopyJavaDoc, - CodeStyleSettingsManager.getSettings(aClass.getProject()).INSERT_OVERRIDE_ANNOTATION); + CodeStyleSettingsManager.getSettings(aClass.getProject()) + .getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION); } public static boolean isInsertOverride(PsiMethod superMethod, PsiClass targetClass) { - if (!CodeStyleSettingsManager.getSettings(targetClass.getProject()).INSERT_OVERRIDE_ANNOTATION) { + if (!CodeStyleSettingsManager.getSettings(targetClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION) { return false; } return canInsertOverride(superMethod, targetClass); @@ -199,7 +197,8 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil { annotateOnOverrideImplement(result, aClass, method, insertOverrideIfPossible); - if (CodeStyleSettingsManager.getSettings(aClass.getProject()).REPEAT_SYNCHRONIZED && method.hasModifierProperty(PsiModifier.SYNCHRONIZED)) { + if (CodeStyleSettingsManager.getSettings(aClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).REPEAT_SYNCHRONIZED && + method.hasModifierProperty(PsiModifier.SYNCHRONIZED)) { result.getModifierList().setModifierProperty(PsiModifier.SYNCHRONIZED, true); } @@ -235,7 +234,8 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil { public static void annotateOnOverrideImplement(PsiMethod method, PsiClass targetClass, PsiMethod overridden) { annotateOnOverrideImplement(method, targetClass, overridden, - CodeStyleSettingsManager.getSettings(method.getProject()).INSERT_OVERRIDE_ANNOTATION); + CodeStyleSettingsManager.getSettings(method.getProject()) + .getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION); } public static void annotateOnOverrideImplement(PsiMethod method, PsiClass targetClass, PsiMethod overridden, boolean insertOverride) { @@ -618,13 +618,15 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil { } public static void overrideOrImplementMethodsInRightPlace(Editor editor1, PsiClass aClass, Collection members, boolean copyJavadoc) { - boolean insert = CodeStyleSettingsManager.getSettings(aClass.getProject()).INSERT_OVERRIDE_ANNOTATION; + boolean insert = + CodeStyleSettingsManager.getSettings(aClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION; overrideOrImplementMethodsInRightPlace(editor1, aClass, members, copyJavadoc, insert); } public static List overrideOrImplementMethodCandidates(PsiClass aClass, Collection candidatesToImplement, boolean copyJavadoc) throws IncorrectOperationException { - boolean insert = CodeStyleSettingsManager.getSettings(aClass.getProject()).INSERT_OVERRIDE_ANNOTATION; + boolean insert = + CodeStyleSettingsManager.getSettings(aClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION; return overrideOrImplementMethodCandidates(aClass, candidatesToImplement, copyJavadoc, insert); } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java index fd35ed3c147f..ccae8267b4c6 100644 --- a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java +++ b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementsAnnotationsHandlerImpl.java @@ -21,6 +21,7 @@ import com.intellij.codeInsight.NullableNotNullManager; import com.intellij.openapi.project.Project; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.util.ArrayUtil; import java.util.ArrayList; @@ -38,7 +39,7 @@ public class OverrideImplementsAnnotationsHandlerImpl implements OverrideImpleme annotations.add(AnnotationUtil.NLS); CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project); - annotations.addAll(settings.getRepeatAnnotations()); + annotations.addAll(settings.getCustomSettings(JavaCodeStyleSettings.class).getRepeatAnnotations()); return ArrayUtil.toStringArray(annotations); } diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/BindFieldsFromParametersAction.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/BindFieldsFromParametersAction.java index ac6b747d1f59..67f46339660d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/BindFieldsFromParametersAction.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/BindFieldsFromParametersAction.java @@ -166,7 +166,7 @@ public class BindFieldsFromParametersAction extends BaseIntentionAction implemen for (PsiParameter parameter : parameters) { types.putValue(parameter.getType(), parameter); } - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class); final boolean preferLongerNames = settings.PREFER_LONGER_NAMES; for (PsiParameter selected : parameters) { try { diff --git a/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java b/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java index 4ef8908fcf1e..adb94c012537 100644 --- a/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java +++ b/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java @@ -220,7 +220,8 @@ public class JavaLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSett public DocCommentSettings getDocCommentSettings(@NotNull PsiFile file) { if (file.isValid()) { return new DocCommentSettings() { - private final CodeStyleSettings mySettings = CodeStyleSettingsManager.getSettings(file.getProject()); + private final JavaCodeStyleSettings mySettings = + CodeStyleSettingsManager.getSettings(file.getProject()).getCustomSettings(JavaCodeStyleSettings.class); @Override public boolean isDocFormattingEnabled() { diff --git a/java/java-impl/src/com/intellij/javadoc/EnterInJavadocParamDescriptionHandler.java b/java/java-impl/src/com/intellij/javadoc/EnterInJavadocParamDescriptionHandler.java index 43a24fbb65c6..8e983f9b9fef 100644 --- a/java/java-impl/src/com/intellij/javadoc/EnterInJavadocParamDescriptionHandler.java +++ b/java/java-impl/src/com/intellij/javadoc/EnterInJavadocParamDescriptionHandler.java @@ -2,7 +2,6 @@ package com.intellij.javadoc; import com.intellij.codeInsight.CodeInsightSettings; import com.intellij.codeInsight.editorActions.enter.EnterHandlerDelegateAdapter; -import com.intellij.ide.highlighter.JavaFileType; import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.editor.CaretModel; @@ -15,6 +14,7 @@ import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiJavaFile; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.util.text.CharArrayUtil; import org.jetbrains.annotations.NotNull; @@ -32,7 +32,7 @@ public class EnterInJavadocParamDescriptionHandler extends EnterHandlerDelegateA public Result postProcessEnter(@NotNull final PsiFile file, @NotNull Editor editor, @NotNull DataContext dataContext) { if (!(file instanceof PsiJavaFile) || !CodeInsightSettings.getInstance().SMART_INDENT_ON_ENTER - || !CodeStyleSettingsManager.getSettings(file.getProject()).JD_ALIGN_PARAM_COMMENTS) { + || !CodeStyleSettingsManager.getSettings(file.getProject()).getCustomSettings(JavaCodeStyleSettings.class).JD_ALIGN_PARAM_COMMENTS) { return Result.Continue; } final CaretModel caretModel = editor.getCaretModel(); diff --git a/java/java-impl/src/com/intellij/javadoc/JavadocHelper.java b/java/java-impl/src/com/intellij/javadoc/JavadocHelper.java index b96d77cac98f..d7d2da789afc 100644 --- a/java/java-impl/src/com/intellij/javadoc/JavadocHelper.java +++ b/java/java-impl/src/com/intellij/javadoc/JavadocHelper.java @@ -27,6 +27,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.javadoc.PsiDocTag; import com.intellij.psi.javadoc.PsiDocTagValue; import com.intellij.psi.javadoc.PsiDocToken; @@ -108,7 +109,7 @@ public class JavadocHelper { final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getInstance(psiFile.getProject()).getCurrentSettings(); int column; - if (codeStyleSettings.JD_ALIGN_PARAM_COMMENTS) { + if (codeStyleSettings.getCustomSettings(JavaCodeStyleSettings.class).JD_ALIGN_PARAM_COMMENTS) { column = Math.max(descriptionStartColumn, parameterNameEndColumn); if (column <= parameterNameEndColumn) { column = parameterNameEndColumn + 1; diff --git a/java/java-impl/src/com/intellij/lang/java/JavaDocumentationProvider.java b/java/java-impl/src/com/intellij/lang/java/JavaDocumentationProvider.java index 789b17332a96..7e90b42833fc 100644 --- a/java/java-impl/src/com/intellij/lang/java/JavaDocumentationProvider.java +++ b/java/java-impl/src/com/intellij/lang/java/JavaDocumentationProvider.java @@ -428,13 +428,13 @@ public class JavaDocumentationProvider extends DocumentationProviderEx implement createTypeParamsListComment(builder, project, commenter, typeParameterList); } if (psiMethod.getReturnType() != null && !PsiType.VOID.equals(psiMethod.getReturnType())) { - builder.append(CodeDocumentationUtil.createDocCommentLine(RETURN_TAG, project, commenter)); + builder.append(CodeDocumentationUtil.createDocCommentLine(RETURN_TAG, _comment.getContainingFile(), commenter)); builder.append(LINE_SEPARATOR); } final PsiJavaCodeReferenceElement[] references = psiMethod.getThrowsList().getReferenceElements(); for (PsiJavaCodeReferenceElement reference : references) { - builder.append(CodeDocumentationUtil.createDocCommentLine(THROWS_TAG, project, commenter)); + builder.append(CodeDocumentationUtil.createDocCommentLine(THROWS_TAG, _comment.getContainingFile(), commenter)); builder.append(reference.getText()); builder.append(LINE_SEPARATOR); } @@ -481,12 +481,12 @@ public class JavaDocumentationProvider extends DocumentationProviderEx implement for (PsiParameter parameter : parameters) { String description = param2Description.get(parameter.getName()); if (description != null) { - builder.append(CodeDocumentationUtil.createDocCommentLine("", project, commenter)); + builder.append(CodeDocumentationUtil.createDocCommentLine("", psiMethod.getContainingFile(), commenter)); if (description.indexOf('\n') > -1) description = description.substring(0, description.lastIndexOf('\n')); builder.append(description); } else { - builder.append(CodeDocumentationUtil.createDocCommentLine(PARAM_TAG, project, commenter)); + builder.append(CodeDocumentationUtil.createDocCommentLine(PARAM_TAG, psiMethod.getContainingFile(), commenter)); builder.append(parameter.getName()); } builder.append(LINE_SEPARATOR); @@ -499,7 +499,7 @@ public class JavaDocumentationProvider extends DocumentationProviderEx implement final PsiTypeParameterList typeParameterList) { final PsiTypeParameter[] typeParameters = typeParameterList.getTypeParameters(); for (PsiTypeParameter typeParameter : typeParameters) { - buffer.append(CodeDocumentationUtil.createDocCommentLine(PARAM_TAG, project, commenter)); + buffer.append(CodeDocumentationUtil.createDocCommentLine(PARAM_TAG, typeParameterList.getContainingFile(), commenter)); buffer.append("<").append(typeParameter.getName()).append(">"); buffer.append(LINE_SEPARATOR); } diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettings.java b/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettings.java index d31f94e11175..ce0dce9b5f03 100644 --- a/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettings.java +++ b/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettings.java @@ -15,11 +15,65 @@ */ package com.intellij.psi.codeStyle; -public class JavaCodeStyleSettings extends CustomCodeStyleSettings { +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.InvalidDataException; +import com.intellij.openapi.util.WriteExternalException; +import org.jdom.Element; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.List; + +public class JavaCodeStyleSettings extends CustomCodeStyleSettings implements ImportsLayoutSettings { + @NonNls private static final String REPEAT_ANNOTATIONS = "REPEAT_ANNOTATIONS"; public JavaCodeStyleSettings(CodeStyleSettings container) { super("JavaCodeStyleSettings", container); + initTypeToName(); + initImportsByDefault(); } + public String FIELD_NAME_PREFIX = ""; + public String STATIC_FIELD_NAME_PREFIX = ""; + public String PARAMETER_NAME_PREFIX = ""; + public String LOCAL_VARIABLE_NAME_PREFIX = ""; + + public String FIELD_NAME_SUFFIX = ""; + public String STATIC_FIELD_NAME_SUFFIX = ""; + public String PARAMETER_NAME_SUFFIX = ""; + public String LOCAL_VARIABLE_NAME_SUFFIX = ""; + + public boolean PREFER_LONGER_NAMES = true; + + public boolean GENERATE_FINAL_LOCALS; + public boolean GENERATE_FINAL_PARAMETERS; + + public String VISIBILITY = "public"; + + public final CodeStyleSettings.TypeToNameMap FIELD_TYPE_TO_NAME = new CodeStyleSettings.TypeToNameMap(); + public final CodeStyleSettings.TypeToNameMap STATIC_FIELD_TYPE_TO_NAME = new CodeStyleSettings.TypeToNameMap(); + @NonNls public final CodeStyleSettings.TypeToNameMap PARAMETER_TYPE_TO_NAME = new CodeStyleSettings.TypeToNameMap(); + public final CodeStyleSettings.TypeToNameMap LOCAL_VARIABLE_TYPE_TO_NAME = new CodeStyleSettings.TypeToNameMap(); + + public boolean USE_EXTERNAL_ANNOTATIONS; + public boolean INSERT_OVERRIDE_ANNOTATION = true; + + public boolean REPEAT_SYNCHRONIZED = true; + + private List myRepeatAnnotations = new ArrayList<>(); + + public List getRepeatAnnotations() { + return myRepeatAnnotations; + } + + public void setRepeatAnnotations(List repeatAnnotations) { + myRepeatAnnotations.clear(); + myRepeatAnnotations.addAll(repeatAnnotations); + } + + public boolean REPLACE_INSTANCEOF = false; + public boolean REPLACE_CAST = false; + public boolean REPLACE_NULL_CHECK = true; public boolean SPACES_WITHIN_ANGLE_BRACKETS; @@ -46,14 +100,251 @@ public class JavaCodeStyleSettings extends CustomCodeStyleSettings { public boolean useFqNamesInJavadocAlways() { return CLASS_NAMES_IN_JAVADOC == FULLY_QUALIFY_NAMES_ALWAYS; } + + // Imports + public boolean LAYOUT_STATIC_IMPORTS_SEPARATELY = true; + public boolean USE_FQ_CLASS_NAMES; + public boolean USE_SINGLE_CLASS_IMPORTS = true; + public boolean INSERT_INNER_CLASS_IMPORTS; + public int CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 5; + public int NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = 3; + public final PackageEntryTable PACKAGES_TO_USE_IMPORT_ON_DEMAND = new PackageEntryTable(); + public final PackageEntryTable IMPORT_LAYOUT_TABLE = new PackageEntryTable(); + + // region JavaDoc + public boolean ENABLE_JAVADOC_FORMATTING = true; + public boolean JD_ALIGN_PARAM_COMMENTS = true; + public boolean JD_ALIGN_EXCEPTION_COMMENTS = true; + public boolean JD_ADD_BLANK_AFTER_PARM_COMMENTS; + public boolean JD_ADD_BLANK_AFTER_RETURN; + public boolean JD_ADD_BLANK_AFTER_DESCRIPTION = true; + public boolean JD_P_AT_EMPTY_LINES = true; + + public boolean JD_KEEP_INVALID_TAGS = true; + public boolean JD_KEEP_EMPTY_LINES = true; + public boolean JD_DO_NOT_WRAP_ONE_LINE_COMMENTS; + + public boolean JD_USE_THROWS_NOT_EXCEPTION = true; + public boolean JD_KEEP_EMPTY_PARAMETER = true; + public boolean JD_KEEP_EMPTY_EXCEPTION = true; + public boolean JD_KEEP_EMPTY_RETURN = true; + + + public boolean JD_LEADING_ASTERISKS_ARE_ENABLED = true; + public boolean JD_PRESERVE_LINE_FEEDS; + public boolean JD_PARAM_DESCRIPTION_ON_NEW_LINE; + + public boolean JD_INDENT_ON_CONTINUATION = false; + + // endregion @Override - protected void importLegacySettings() { - CodeStyleSettings settings = getContainer(); - boolean isDefaultValue = settings.USE_FQ_CLASS_NAMES_IN_JAVADOC; - if (!isDefaultValue) { - CLASS_NAMES_IN_JAVADOC = SHORTEN_NAMES_ALWAYS_AND_ADD_IMPORT; - settings.USE_FQ_CLASS_NAMES_IN_JAVADOC = true; + public boolean isLayoutStaticImportsSeparately() { + return LAYOUT_STATIC_IMPORTS_SEPARATELY; + } + + @Override + public void setLayoutStaticImportsSeparately(boolean value) { + LAYOUT_STATIC_IMPORTS_SEPARATELY = value; + + } + + @Override + public int getNamesCountToUseImportOnDemand() { + return NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND; + } + + @Override + public void setNamesCountToUseImportOnDemand(int value) { + NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = value; + } + + @Override + public int getClassCountToUseImportOnDemand() { + return CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND; + } + + @Override + public void setClassCountToUseImportOnDemand(int value) { + CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = value; + } + + @Override + public boolean isInsertInnerClassImports() { + return INSERT_INNER_CLASS_IMPORTS; + } + + @Override + public void setInsertInnerClassImports(boolean value) { + INSERT_INNER_CLASS_IMPORTS = value; + } + + @Override + public boolean isUseSingleClassImports() { + return USE_SINGLE_CLASS_IMPORTS; + } + + @Override + public void setUseSingleClassImports(boolean value) { + USE_SINGLE_CLASS_IMPORTS = value; + } + + @Override + public boolean isUseFqClassNames() { + return USE_FQ_CLASS_NAMES; + } + + @Override + public void setUseFqClassNames(boolean value) { + USE_FQ_CLASS_NAMES = value; + } + + @Override + public PackageEntryTable getImportLayoutTable() { + return IMPORT_LAYOUT_TABLE; + } + + @Override + public PackageEntryTable getPackagesToUseImportOnDemand() { + return PACKAGES_TO_USE_IMPORT_ON_DEMAND; + } + + private void initImportsByDefault() { + PACKAGES_TO_USE_IMPORT_ON_DEMAND.addEntry(new PackageEntry(false, "java.awt", false)); + PACKAGES_TO_USE_IMPORT_ON_DEMAND.addEntry(new PackageEntry(false,"javax.swing", false)); + IMPORT_LAYOUT_TABLE.addEntry(PackageEntry.ALL_OTHER_IMPORTS_ENTRY); + IMPORT_LAYOUT_TABLE.addEntry(PackageEntry.BLANK_LINE_ENTRY); + IMPORT_LAYOUT_TABLE.addEntry(new PackageEntry(false, "javax", true)); + IMPORT_LAYOUT_TABLE.addEntry(new PackageEntry(false, "java", true)); + IMPORT_LAYOUT_TABLE.addEntry(PackageEntry.BLANK_LINE_ENTRY); + IMPORT_LAYOUT_TABLE.addEntry(PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY); + } + + + @SuppressWarnings("unused") // Used in objectEquals.vm + public boolean isGenerateFinalLocals() { + return GENERATE_FINAL_LOCALS; + } + + @SuppressWarnings("unused") // Used in objectEquals.vm + public boolean isGenerateFinalParameters() { + return GENERATE_FINAL_PARAMETERS; + } + + @SuppressWarnings("Duplicates") + private static void initGeneralLocalVariable(@NonNls CodeStyleSettings.TypeToNameMap map) { + map.addPair("int", "i"); + map.addPair("byte", "b"); + map.addPair("char", "c"); + map.addPair("long", "l"); + map.addPair("short", "i"); + map.addPair("boolean", "b"); + map.addPair("double", "v"); + map.addPair("float", "v"); + map.addPair("java.lang.Object", "o"); + map.addPair("java.lang.String", "s"); + } + + private void initTypeToName() { + initGeneralLocalVariable(PARAMETER_TYPE_TO_NAME); + initGeneralLocalVariable(LOCAL_VARIABLE_TYPE_TO_NAME); + PARAMETER_TYPE_TO_NAME.addPair("*Exception", "e"); + } + + @SuppressWarnings("deprecation") + @Override + protected void importLegacySettings(@NotNull CodeStyleSettings rootSettings) { + USE_EXTERNAL_ANNOTATIONS = rootSettings.USE_EXTERNAL_ANNOTATIONS; + INSERT_OVERRIDE_ANNOTATION = rootSettings.INSERT_OVERRIDE_ANNOTATION; + REPEAT_SYNCHRONIZED = rootSettings.REPEAT_SYNCHRONIZED; + setRepeatAnnotations(rootSettings.getRepeatAnnotations()); + LAYOUT_STATIC_IMPORTS_SEPARATELY = rootSettings.LAYOUT_STATIC_IMPORTS_SEPARATELY; + USE_FQ_CLASS_NAMES = rootSettings.USE_FQ_CLASS_NAMES; + USE_SINGLE_CLASS_IMPORTS = rootSettings.USE_SINGLE_CLASS_IMPORTS; + INSERT_INNER_CLASS_IMPORTS = rootSettings.INSERT_INNER_CLASS_IMPORTS; + CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = rootSettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND; + NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = rootSettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND; + PACKAGES_TO_USE_IMPORT_ON_DEMAND.copyFrom(rootSettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND); + IMPORT_LAYOUT_TABLE.copyFrom(rootSettings.IMPORT_LAYOUT_TABLE); + REPLACE_INSTANCEOF = rootSettings.REPLACE_INSTANCEOF; + REPLACE_CAST = rootSettings.REPLACE_CAST; + REPLACE_NULL_CHECK = rootSettings.REPLACE_NULL_CHECK; + FIELD_NAME_PREFIX = rootSettings.FIELD_NAME_PREFIX; + STATIC_FIELD_NAME_PREFIX = rootSettings.STATIC_FIELD_NAME_PREFIX; + PARAMETER_NAME_PREFIX = rootSettings.PARAMETER_NAME_PREFIX; + LOCAL_VARIABLE_NAME_PREFIX = rootSettings.LOCAL_VARIABLE_NAME_PREFIX; + + FIELD_NAME_SUFFIX = rootSettings.FIELD_NAME_SUFFIX; + STATIC_FIELD_NAME_SUFFIX = rootSettings.STATIC_FIELD_NAME_SUFFIX; + PARAMETER_NAME_SUFFIX = rootSettings.PARAMETER_NAME_SUFFIX; + LOCAL_VARIABLE_NAME_SUFFIX = rootSettings.LOCAL_VARIABLE_NAME_SUFFIX; + + PREFER_LONGER_NAMES = rootSettings.PREFER_LONGER_NAMES; + GENERATE_FINAL_LOCALS = rootSettings.GENERATE_FINAL_LOCALS; + GENERATE_FINAL_PARAMETERS = rootSettings.GENERATE_FINAL_PARAMETERS; + VISIBILITY = rootSettings.VISIBILITY; + FIELD_TYPE_TO_NAME.copyFrom(rootSettings.FIELD_TYPE_TO_NAME); + LOCAL_VARIABLE_TYPE_TO_NAME.copyFrom(rootSettings.LOCAL_VARIABLE_TYPE_TO_NAME); + PARAMETER_TYPE_TO_NAME.copyFrom(rootSettings.PARAMETER_TYPE_TO_NAME); + STATIC_FIELD_TYPE_TO_NAME.copyFrom(rootSettings.STATIC_FIELD_TYPE_TO_NAME); + + ENABLE_JAVADOC_FORMATTING = rootSettings.ENABLE_JAVADOC_FORMATTING; + JD_ALIGN_PARAM_COMMENTS = rootSettings.JD_ALIGN_PARAM_COMMENTS; + JD_ALIGN_EXCEPTION_COMMENTS = rootSettings.JD_ALIGN_EXCEPTION_COMMENTS; + JD_ADD_BLANK_AFTER_PARM_COMMENTS = rootSettings.JD_ADD_BLANK_AFTER_PARM_COMMENTS; + JD_ADD_BLANK_AFTER_RETURN = rootSettings.JD_ADD_BLANK_AFTER_RETURN; + JD_ADD_BLANK_AFTER_DESCRIPTION = rootSettings.JD_ADD_BLANK_AFTER_DESCRIPTION; + JD_P_AT_EMPTY_LINES = rootSettings.JD_P_AT_EMPTY_LINES; + + JD_KEEP_INVALID_TAGS = rootSettings.JD_KEEP_INVALID_TAGS; + JD_KEEP_EMPTY_LINES = rootSettings.JD_KEEP_EMPTY_LINES; + JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = rootSettings.JD_DO_NOT_WRAP_ONE_LINE_COMMENTS; + + JD_USE_THROWS_NOT_EXCEPTION = rootSettings.JD_USE_THROWS_NOT_EXCEPTION; + JD_KEEP_EMPTY_PARAMETER = rootSettings.JD_KEEP_EMPTY_PARAMETER; + JD_KEEP_EMPTY_EXCEPTION = rootSettings.JD_KEEP_EMPTY_EXCEPTION; + JD_KEEP_EMPTY_RETURN = rootSettings.JD_KEEP_EMPTY_RETURN; + + + JD_LEADING_ASTERISKS_ARE_ENABLED = rootSettings.JD_LEADING_ASTERISKS_ARE_ENABLED; + JD_PRESERVE_LINE_FEEDS = rootSettings.JD_PRESERVE_LINE_FEEDS; + JD_PARAM_DESCRIPTION_ON_NEW_LINE = rootSettings.JD_PARAM_DESCRIPTION_ON_NEW_LINE; + + JD_INDENT_ON_CONTINUATION = rootSettings.JD_INDENT_ON_CONTINUATION; + } + + @Override + public void readExternal(Element parentElement) throws InvalidDataException { + super.readExternal(parentElement); + Element child = parentElement.getChild(getTagName()); + if (child != null) { + myRepeatAnnotations.clear(); + Element annotations = child.getChild(REPEAT_ANNOTATIONS); + if (annotations != null) { + for (Element anno : annotations.getChildren("ANNO")) { + myRepeatAnnotations.add(anno.getAttributeValue("name")); + } + } } } + + @Override + public void writeExternal(Element parentElement, @NotNull CustomCodeStyleSettings parentSettings) throws WriteExternalException { + super.writeExternal(parentElement, parentSettings); + if (!myRepeatAnnotations.isEmpty()) { + Element child = parentElement.getChild(getTagName()); + if (child == null) { + child = new Element(getTagName()); + } + Element annos = new Element(REPEAT_ANNOTATIONS); + for (String annotation : myRepeatAnnotations) { + annos.addContent(new Element("ANNO").setAttribute("name", annotation)); + } + child.addContent(annos); + } + } + + public static JavaCodeStyleSettings getInstance(@NotNull Project project) { + return CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class); + } } diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettingsFacadeImpl.java b/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettingsFacadeImpl.java index adccd0550804..c50c2e3db59d 100644 --- a/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettingsFacadeImpl.java +++ b/java/java-impl/src/com/intellij/psi/codeStyle/JavaCodeStyleSettingsFacadeImpl.java @@ -29,17 +29,17 @@ public class JavaCodeStyleSettingsFacadeImpl extends JavaCodeStyleSettingsFacade @Override public int getNamesCountToUseImportOnDemand() { - return myManager.getCurrentSettings().NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND; + return myManager.getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class).NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND; } @Override public boolean useFQClassNames() { - return myManager.getCurrentSettings().USE_FQ_CLASS_NAMES; + return myManager.getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class).USE_FQ_CLASS_NAMES; } @Override public boolean isJavaDocLeadingAsterisksEnabled() { - return myManager.getCurrentSettings().JD_LEADING_ASTERISKS_ARE_ENABLED; + return myManager.getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class).JD_LEADING_ASTERISKS_ARE_ENABLED; } @Override @@ -49,11 +49,11 @@ public class JavaCodeStyleSettingsFacadeImpl extends JavaCodeStyleSettingsFacade @Override public boolean isGenerateFinalParameters() { - return myManager.getCurrentSettings().GENERATE_FINAL_PARAMETERS; + return myManager.getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS; } @Override public boolean isGenerateFinalLocals() { - return myManager.getCurrentSettings().GENERATE_FINAL_LOCALS; + return myManager.getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS; } } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/FormatCommentsProcessor.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/FormatCommentsProcessor.java index 994e1684a3e6..14e5ecec5a8b 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/FormatCommentsProcessor.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/FormatCommentsProcessor.java @@ -25,6 +25,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiField; import com.intellij.psi.PsiMethod; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.source.SourceTreeToPsiMap; import com.intellij.psi.impl.source.codeStyle.javadoc.CommentFormatter; import com.intellij.psi.javadoc.PsiDocComment; @@ -37,7 +38,7 @@ public class FormatCommentsProcessor implements PreFormatProcessor { PsiElement e = SourceTreeToPsiMap.treeElementToPsi(element); assert e != null; final Project project = e.getProject(); - if (!CodeStyleSettingsManager.getSettings(project).ENABLE_JAVADOC_FORMATTING || + if (!CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).ENABLE_JAVADOC_FORMATTING || element.getPsi().getContainingFile().getLanguage() != JavaLanguage.INSTANCE || InjectedLanguageManager.getInstance(project).isInjectedFragment(element.getPsi().getContainingFile())) { diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java index 01aa96d0f53e..738a3073987e 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java @@ -25,10 +25,7 @@ import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettings; -import com.intellij.psi.codeStyle.PackageEntry; -import com.intellij.psi.codeStyle.PackageEntryTable; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.impl.source.PsiJavaCodeReferenceElementImpl; import com.intellij.psi.impl.source.SourceTreeToPsiMap; import com.intellij.psi.impl.source.jsp.jspJava.JspxImportStatement; @@ -65,11 +62,11 @@ import static java.util.stream.Collectors.toSet; public class ImportHelper{ private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.codeStyle.ImportHelper"); - private final CodeStyleSettings mySettings; + private final JavaCodeStyleSettings mySettings; @NonNls private static final String JAVA_LANG_PACKAGE = "java.lang"; public ImportHelper(@NotNull CodeStyleSettings settings){ - mySettings = settings; + mySettings = settings.getCustomSettings(JavaCodeStyleSettings.class); } @Nullable("null means no need to replace the import list because they are the same") @@ -149,7 +146,7 @@ public class ImportHelper{ } public static void collectOnDemandImports(@NotNull List> resultList, - @NotNull CodeStyleSettings settings, + @NotNull JavaCodeStyleSettings settings, @NotNull Map outClassesOrPackagesToImportOnDemand) { TObjectIntHashMap packageToCountMap = new TObjectIntHashMap<>(); TObjectIntHashMap classToCountMap = new TObjectIntHashMap<>(); @@ -189,7 +186,7 @@ public class ImportHelper{ packageToCountMap.forEachEntry(new MyVisitorProcedure(true)); } - public static List> sortItemsAccordingToSettings(List> names, final CodeStyleSettings settings) { + public static List> sortItemsAccordingToSettings(List> names, final JavaCodeStyleSettings settings) { int[] entryForName = ArrayUtil.newIntArray(names.size()); PackageEntry[] entries = settings.IMPORT_LAYOUT_TABLE.getEntries(); for(int i = 0; i < names.size(); i++){ @@ -732,7 +729,7 @@ public class ImportHelper{ private static boolean isToUseImportOnDemand(@NotNull String packageName, int classCount, boolean isStaticImportNeeded, - @NotNull CodeStyleSettings settings){ + @NotNull JavaCodeStyleSettings settings){ if (!settings.USE_SINGLE_CLASS_IMPORTS) return true; int limitCount = isStaticImportNeeded ? settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND : settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND; diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaCodeStyleManagerImpl.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaCodeStyleManagerImpl.java index 7281d2314488..0a42deeab943 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaCodeStyleManagerImpl.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaCodeStyleManagerImpl.java @@ -889,7 +889,7 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager { @NotNull private String[] getSuggestionsByName(@NotNull String name, @NotNull VariableKind variableKind, boolean isArray, boolean correctKeywords) { boolean upperCaseStyle = variableKind == VariableKind.STATIC_FINAL_FIELD; - boolean preferLongerNames = getSettings().PREFER_LONGER_NAMES; + boolean preferLongerNames = getJavaSettings().PREFER_LONGER_NAMES; String prefix = getPrefixByVariableKind(variableKind); String suffix = getSuffixByVariableKind(variableKind); @@ -1071,16 +1071,16 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager { String prefix = ""; switch (variableKind) { case FIELD: - prefix = getSettings().FIELD_NAME_PREFIX; + prefix = getJavaSettings().FIELD_NAME_PREFIX; break; case STATIC_FIELD: - prefix = getSettings().STATIC_FIELD_NAME_PREFIX; + prefix = getJavaSettings().STATIC_FIELD_NAME_PREFIX; break; case PARAMETER: - prefix = getSettings().PARAMETER_NAME_PREFIX; + prefix = getJavaSettings().PARAMETER_NAME_PREFIX; break; case LOCAL_VARIABLE: - prefix = getSettings().LOCAL_VARIABLE_NAME_PREFIX; + prefix = getJavaSettings().LOCAL_VARIABLE_NAME_PREFIX; break; case STATIC_FINAL_FIELD: prefix = ""; @@ -1101,16 +1101,16 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager { String suffix = ""; switch (variableKind) { case FIELD: - suffix = getSettings().FIELD_NAME_SUFFIX; + suffix = getJavaSettings().FIELD_NAME_SUFFIX; break; case STATIC_FIELD: - suffix = getSettings().STATIC_FIELD_NAME_SUFFIX; + suffix = getJavaSettings().STATIC_FIELD_NAME_SUFFIX; break; case PARAMETER: - suffix = getSettings().PARAMETER_NAME_SUFFIX; + suffix = getJavaSettings().PARAMETER_NAME_SUFFIX; break; case LOCAL_VARIABLE: - suffix = getSettings().LOCAL_VARIABLE_NAME_SUFFIX; + suffix = getJavaSettings().LOCAL_VARIABLE_NAME_SUFFIX; break; case STATIC_FINAL_FIELD: suffix = ""; @@ -1127,10 +1127,10 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager { @Nullable private CodeStyleSettings.TypeToNameMap getMapByVariableKind(@NotNull VariableKind variableKind) { - if (variableKind == VariableKind.FIELD) return getSettings().FIELD_TYPE_TO_NAME; - if (variableKind == VariableKind.STATIC_FIELD) return getSettings().STATIC_FIELD_TYPE_TO_NAME; - if (variableKind == VariableKind.PARAMETER) return getSettings().PARAMETER_TYPE_TO_NAME; - if (variableKind == VariableKind.LOCAL_VARIABLE) return getSettings().LOCAL_VARIABLE_TYPE_TO_NAME; + if (variableKind == VariableKind.FIELD) return getJavaSettings().FIELD_TYPE_TO_NAME; + if (variableKind == VariableKind.STATIC_FIELD) return getJavaSettings().STATIC_FIELD_TYPE_TO_NAME; + if (variableKind == VariableKind.PARAMETER) return getJavaSettings().PARAMETER_TYPE_TO_NAME; + if (variableKind == VariableKind.LOCAL_VARIABLE) return getJavaSettings().LOCAL_VARIABLE_TYPE_TO_NAME; return null; } @@ -1152,6 +1152,11 @@ public class JavaCodeStyleManagerImpl extends JavaCodeStyleManager { return CodeStyleSettingsManager.getSettings(myProject); } + @NotNull + private JavaCodeStyleSettings getJavaSettings() { + return getSettings().getCustomSettings(JavaCodeStyleSettings.class); + } + private static boolean isStringPsiLiteral(@NotNull PsiElement element) { if (element instanceof PsiLiteralExpression) { final String text = element.getText(); diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaReferenceAdjuster.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaReferenceAdjuster.java index 1d08515f9f3f..dda1d03d017c 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaReferenceAdjuster.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/JavaReferenceAdjuster.java @@ -136,7 +136,7 @@ public class JavaReferenceAdjuster implements ReferenceAdjuster { public ASTNode process(@NotNull ASTNode element, boolean addImports, boolean incompleteCode, Project project) { final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project); JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); - return process(element, addImports, incompleteCode, javaSettings.useFqNamesInJavadocAlways(), settings.USE_FQ_CLASS_NAMES); + return process(element, addImports, incompleteCode, javaSettings.useFqNamesInJavadocAlways(), javaSettings.USE_FQ_CLASS_NAMES); } private static boolean isAnnotated(ASTNode element) { @@ -179,7 +179,7 @@ public class JavaReferenceAdjuster implements ReferenceAdjuster { public void processRange(@NotNull ASTNode element, int startOffset, int endOffset, Project project) { final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project); JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); - processRange(element, startOffset, endOffset, javaSettings.useFqNamesInJavadocAlways(), settings.USE_FQ_CLASS_NAMES); + processRange(element, startOffset, endOffset, javaSettings.useFqNamesInJavadocAlways(), javaSettings.USE_FQ_CLASS_NAMES); } private static void addReferencesInRange(List array, ASTNode parent, int startOffset, int endOffset) { @@ -239,7 +239,7 @@ public class JavaReferenceAdjuster implements ReferenceAdjuster { return reference; } - if (!CodeStyleSettingsManager.getSettings(reference.getProject()).INSERT_INNER_CLASS_IMPORTS) { + if (!CodeStyleSettingsManager.getSettings(reference.getProject()).getCustomSettings(JavaCodeStyleSettings.class).INSERT_INNER_CLASS_IMPORTS) { final PsiElement qualifier = reference.getQualifier(); if (qualifier instanceof PsiQualifiedReferenceElement) { return getClassReferenceToShorten(parentClass, addImports, (PsiQualifiedReferenceElement)qualifier); diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/CommentFormatter.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/CommentFormatter.java index 3845b2bb99c0..a8b536cd85fb 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/CommentFormatter.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/CommentFormatter.java @@ -20,12 +20,12 @@ import com.intellij.lang.ASTNode; import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; -import com.intellij.openapi.roots.LanguageLevelProjectExtension; import com.intellij.openapi.util.text.LineTokenizer; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.source.SourceTreeToPsiMap; import com.intellij.psi.javadoc.PsiDocComment; import com.intellij.psi.util.PsiUtil; @@ -53,8 +53,8 @@ public class CommentFormatter { myProject = project; } - public CodeStyleSettings getSettings() { - return mySettings; + public JavaCodeStyleSettings getSettings() { + return mySettings.getCustomSettings(JavaCodeStyleSettings.class); } public JDParser getParser() { diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDComment.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDComment.java index c7c4b6bd8fdc..f91057929b24 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDComment.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDComment.java @@ -64,7 +64,7 @@ public class JDComment { @NotNull protected String continuationIndent() { - CodeStyleSettings settings = myFormatter.getSettings(); + CodeStyleSettings settings = myFormatter.getSettings().getContainer(); CommonCodeStyleSettings.IndentOptions indentOptions = settings.getIndentOptions(JavaFileType.INSTANCE); return new IndentInfo(0, indentOptions.CONTINUATION_INDENT_SIZE, 0).generateNewWhiteSpace(indentOptions); } diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDParser.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDParser.java index 5705a29a9552..f82dc9df1954 100644 --- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDParser.java +++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/javadoc/JDParser.java @@ -20,6 +20,7 @@ import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.javadoc.PsiDocComment; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -43,10 +44,10 @@ public class JDParser { private static final char lineSeparator = '\n'; - private final CodeStyleSettings mySettings; + private final JavaCodeStyleSettings mySettings; public JDParser(@NotNull CodeStyleSettings settings) { - mySettings = settings; + mySettings = settings.getCustomSettings(JavaCodeStyleSettings.class); } public void formatCommentText(@NotNull PsiElement element, @NotNull CommentFormatter formatter) { @@ -565,7 +566,7 @@ public class JDParser { @NotNull CharSequence firstLinePrefix, @NotNull CharSequence continuationPrefix) { - final int rightMargin = mySettings.getRightMargin(JavaLanguage.INSTANCE); + final int rightMargin = mySettings.getContainer().getRightMargin(JavaLanguage.INSTANCE); final int maxCommentLength = rightMargin - continuationPrefix.length(); final int firstLinePrefixLength = firstLinePrefix.length(); final boolean firstLineShorter = firstLinePrefixLength > continuationPrefix.length(); @@ -576,7 +577,7 @@ public class JDParser { boolean canWrap = !mySettings.JD_PRESERVE_LINE_FEEDS || hasLineLongerThan(str, maxCommentLength); //If wrap comments selected, comments should be wrapped by the right margin - if (mySettings.WRAP_COMMENTS && canWrap) { + if (mySettings.getContainer().WRAP_COMMENTS && canWrap) { list = toArrayWrapping(str, maxCommentLength); if (firstLineShorter diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java index 7083aede4b4a..dd293a2cd6e3 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java @@ -29,10 +29,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.impl.source.resolve.JavaResolveUtil; import com.intellij.psi.scope.processor.VariablesProcessor; import com.intellij.psi.scope.util.PsiScopesUtil; @@ -963,7 +960,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr type = psiSubstitutor.substitute(type); } PsiParameter parameter = factory.createParameter(newParm.getName(), type, list); - if (CodeStyleSettingsManager.getSettings(project).GENERATE_FINAL_PARAMETERS) { + if (CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS) { PsiUtil.setModifierProperty(parameter, PsiModifier.FINAL, true); } return parameter; @@ -1231,7 +1228,8 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr JavaPsiFacade.getElementFactory(method.getProject()).createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, method); } PsiParameter param = factory.createParameter(info.getName(), parameterType, method); - if (CodeStyleSettingsManager.getSettings(manager.getProject()).GENERATE_FINAL_PARAMETERS) { + if (CodeStyleSettingsManager.getSettings(manager.getProject()) + .getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS) { PsiUtil.setModifierProperty(param, PsiModifier.FINAL, true); } prototype.getParameterList().add(param); diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java index 84579ac502fa..c817cc0fc4ea 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java @@ -1191,7 +1191,7 @@ public class ExtractMethodProcessor implements MatchProvider { exc[0] = null; final PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length > 0) { - if (CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS) { + if (CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS) { method.accept(new JavaRecursiveElementVisitor() { @Override public void visitReferenceExpression(PsiReferenceExpression expression) { @@ -1385,7 +1385,7 @@ public class ExtractMethodProcessor implements MatchProvider { PsiCodeBlock body = newMethod.getBody(); LOG.assertTrue(body != null); - boolean isFinal = CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS; + boolean isFinal = CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS; PsiParameterList list = newMethod.getParameterList(); for (VariableData data : myVariableDatum) { if (data.passAsParameter) { diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java index 105ed65a340e..c5bc7d52bab7 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectProcessor.java @@ -28,10 +28,7 @@ import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.controlFlow.ControlFlowUtil; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.LocalSearchScope; @@ -613,7 +610,7 @@ public class ExtractMethodObjectProcessor extends BaseRefactoringProcessor { final String parameterName = parameter.getName(); LOG.assertTrue(parameterName != null); PsiParameter parm = myElementFactory.createParameter(parameterName, parameter.getType()); - if (CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS) { + if (CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS) { final PsiModifierList modifierList = parm.getModifierList(); LOG.assertTrue(modifierList != null); modifierList.setModifierProperty(PsiModifier.FINAL, true); diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java index 3c1b4c2de775..a100a5dafd31 100644 --- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java @@ -28,10 +28,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettings; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.javadoc.PsiDocTagValue; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.searches.ReferencesSearch; @@ -231,7 +228,7 @@ public class ExtractClassProcessor extends FixableUsagesRefactoringProcessor { private String calculateDelegateFieldName() { final Project project = sourceClass.getProject(); final CodeStyleSettingsManager settingsManager = CodeStyleSettingsManager.getInstance(project); - final CodeStyleSettings settings = settingsManager.getCurrentSettings(); + final JavaCodeStyleSettings settings = settingsManager.getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class); final String baseName = settings.FIELD_NAME_PREFIX.length() == 0 ? StringUtil.decapitalize(newClassName) : newClassName; String name = settings.FIELD_NAME_PREFIX + baseName + settings.FIELD_NAME_SUFFIX; diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousConstructorProcessor.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousConstructorProcessor.java index af20819a1ce0..d682c56291fd 100644 --- a/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousConstructorProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineToAnonymousConstructorProcessor.java @@ -26,6 +26,7 @@ import com.intellij.patterns.ElementPattern; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.source.codeStyle.CodeEditUtil; import com.intellij.psi.search.ProjectScope; import com.intellij.psi.util.PsiTreeUtil; @@ -272,7 +273,8 @@ class InlineToAnonymousConstructorProcessor { try { final PsiDeclarationStatement declaration = myElementFactory.createVariableDeclarationStatement(localName, type, initializer); PsiVariable variable = (PsiVariable)declaration.getDeclaredElements()[0]; - if (!PsiUtil.isLanguageLevel8OrHigher(myNewExpression) || CodeStyleSettingsManager.getSettings(project).GENERATE_FINAL_LOCALS) { + if (!PsiUtil.isLanguageLevel8OrHigher(myNewExpression) || + CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS) { PsiUtil.setModifierProperty(variable, PsiModifier.FINAL, true); } final PsiElement parent = myNewStatement.getParent(); diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/InplaceIntroduceParameterUI.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/InplaceIntroduceParameterUI.java index 193d38181cca..a563bea2f410 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/InplaceIntroduceParameterUI.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/InplaceIntroduceParameterUI.java @@ -22,6 +22,7 @@ import com.intellij.psi.PsiLocalVariable; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiParameter; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiUtil; import com.intellij.refactoring.IntroduceParameterRefactoring; import com.intellij.refactoring.JavaRefactoringSettings; @@ -136,6 +137,8 @@ public abstract class InplaceIntroduceParameterUI extends IntroduceParameterSett public boolean hasFinalModifier() { if (myHasWriteAccess) return false; final Boolean createFinals = JavaRefactoringSettings.getInstance().INTRODUCE_PARAMETER_CREATE_FINALS; - return createFinals == null ? CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS : createFinals.booleanValue(); + return createFinals == null ? + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS : + createFinals.booleanValue(); } } diff --git a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java index 4eacebebd31b..d47e5eedae9e 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceParameter/IntroduceParameterDialog.java @@ -24,6 +24,7 @@ import com.intellij.openapi.options.ConfigurationException; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiUtil; import com.intellij.refactoring.HelpID; import com.intellij.refactoring.JavaRefactoringSettings; @@ -208,7 +209,8 @@ public class IntroduceParameterDialog extends RefactoringDialog { final Boolean settingsFinals = settings.INTRODUCE_PARAMETER_CREATE_FINALS; myCbDeclareFinal.setSelected(settingsFinals == null ? - CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS : + CodeStyleSettingsManager.getSettings(myProject) + .getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS : settingsFinals.booleanValue()); panel.add(myCbDeclareFinal, gbConstraints); if (myMustBeFinal) { diff --git a/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableBase.java b/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableBase.java index ff08de967476..ec910ed2abd7 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableBase.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableBase.java @@ -45,10 +45,7 @@ import com.intellij.openapi.util.registry.Registry; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.wm.WindowManager; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.codeStyle.SuggestedNameInfo; -import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.impl.PsiDiamondTypeUtil; import com.intellij.psi.impl.source.jsp.jspJava.JspCodeBlock; import com.intellij.psi.impl.source.jsp.jspJava.JspHolderMethod; @@ -1219,7 +1216,9 @@ public abstract class IntroduceVariableBase extends IntroduceHandlerBase { public static boolean createFinals(Project project) { final Boolean createFinals = JavaRefactoringSettings.getInstance().INTRODUCE_LOCAL_CREATE_FINALS; - return createFinals == null ? CodeStyleSettingsManager.getSettings(project).GENERATE_FINAL_LOCALS : createFinals.booleanValue(); + return createFinals == null ? + CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS : + createFinals.booleanValue(); } public static boolean checkAnchorBeforeThisOrSuper(final Project project, diff --git a/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java b/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java index 45d9497b7e4d..336a8930c5fb 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceVariable/IntroduceVariableDialog.java @@ -22,6 +22,7 @@ import com.intellij.psi.PsiExpression; import com.intellij.psi.PsiNameHelper; import com.intellij.psi.PsiType; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.codeStyle.SuggestedNameInfo; import com.intellij.refactoring.HelpID; import com.intellij.refactoring.JavaRefactoringSettings; @@ -207,7 +208,7 @@ class IntroduceVariableDialog extends DialogWrapper implements IntroduceVariable myCbFinal.setText(RefactoringBundle.message("declare.final")); final Boolean createFinals = JavaRefactoringSettings.getInstance().INTRODUCE_LOCAL_CREATE_FINALS; myCbFinalState = createFinals == null ? - CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_LOCALS : + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS : createFinals.booleanValue(); gbConstraints.insets = JBUI.emptyInsets(); diff --git a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/ParameterObjectBuilder.java b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/ParameterObjectBuilder.java index cda96f595fbb..a4fdefc593ec 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/ParameterObjectBuilder.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/ParameterObjectBuilder.java @@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.codeStyle.VariableKind; import com.intellij.psi.javadoc.PsiDocComment; import org.jetbrains.annotations.NonNls; @@ -134,7 +135,9 @@ class ParameterObjectBuilder { final ParameterSpec field = iterator.next(); final PsiParameter parameter = field.getParameter(); outputAnnotationString(parameter, out); - out.append(CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS ? " final " : ""); + out.append( + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS ? + " final " : ""); final String parameterName = parameter.getName(); final PsiType type = field.getType(); final PsiType fieldType = parameter.isVarArgs() && type instanceof PsiArrayType ? diff --git a/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeClassStaticProcessor.java b/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeClassStaticProcessor.java index 79ae5808f891..1c0e1972abc7 100644 --- a/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeClassStaticProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeClassStaticProcessor.java @@ -18,10 +18,7 @@ package com.intellij.refactoring.makeStatic; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.javadoc.PsiDocTag; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiTreeUtil; @@ -80,7 +77,8 @@ public class MakeClassStaticProcessor extends MakeMethodOrClassStaticProcessor

filterImports(@NotNull List usageInfos, @NotNull Project project) { final List importStatements = new ArrayList<>(); - if (!CodeStyleSettingsManager.getSettings(project).INSERT_INNER_CLASS_IMPORTS) { + if (!CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).INSERT_INNER_CLASS_IMPORTS) { filterUsagesInImportStatements(usageInfos, importStatements); } else { diff --git a/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/ReturnValueBeanBuilder.java b/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/ReturnValueBeanBuilder.java index 299b1345331c..325a9c06fe83 100644 --- a/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/ReturnValueBeanBuilder.java +++ b/java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/ReturnValueBeanBuilder.java @@ -21,6 +21,7 @@ import com.intellij.psi.PsiType; import com.intellij.psi.PsiTypeParameter; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.codeStyle.VariableKind; import java.io.IOException; @@ -106,7 +107,9 @@ class ReturnValueBeanBuilder { final String parameterName = JavaCodeStyleManager.getInstance(myProject).propertyNameToVariableName(name, VariableKind.PARAMETER); final String fieldName = getFieldName(name); out.append("\tpublic ").append(myClassName).append('('); - out.append(CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS ? "final " : ""); + out.append( + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS ? + "final " : ""); out.append(typeText).append(' ').append(parameterName); out.append(") {\n"); if (fieldName.equals(parameterName)) { diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/AddAnnotationFixTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/AddAnnotationFixTest.java index 7452712e2fec..09d1c12e375a 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/AddAnnotationFixTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/AddAnnotationFixTest.java @@ -44,6 +44,7 @@ import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.testFramework.PsiTestUtil; import com.intellij.testFramework.UsefulTestCase; @@ -85,12 +86,12 @@ public class AddAnnotationFixTest extends UsefulTestCase { myModule = builder.getFixture().getModule(); myProject = myFixture.getProject(); - CodeStyleSettingsManager.getSettings(myProject).USE_EXTERNAL_ANNOTATIONS = true; + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS = true; } @Override protected void tearDown() throws Exception { - CodeStyleSettingsManager.getSettings(myProject).USE_EXTERNAL_ANNOTATIONS = false; + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS = false; try { myFixture.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/ExternalAnnotationsTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/ExternalAnnotationsTest.java index 70c7892a188d..4d54d064869f 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/ExternalAnnotationsTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/ExternalAnnotationsTest.java @@ -23,6 +23,7 @@ import com.intellij.openapi.roots.JavaModuleExternalPaths; import com.intellij.openapi.roots.ModuleRootModificationUtil; import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.testFramework.UsefulTestCase; import com.intellij.testFramework.builders.JavaModuleFixtureBuilder; import com.intellij.testFramework.fixtures.*; @@ -54,12 +55,12 @@ public class ExternalAnnotationsTest extends UsefulTestCase { myProject = myFixture.getProject(); - CodeStyleSettingsManager.getSettings(myProject).USE_EXTERNAL_ANNOTATIONS = true; + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS = true; } @Override protected void tearDown() throws Exception { - CodeStyleSettingsManager.getSettings(myProject).USE_EXTERNAL_ANNOTATIONS = false; + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).USE_EXTERNAL_ANNOTATIONS = false; try { myFixture.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateConstructorTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateConstructorTest.java index 4d0a8285399a..51cb9306d196 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateConstructorTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateConstructorTest.java @@ -25,6 +25,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Disposer; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; @@ -69,12 +70,17 @@ public class GenerateConstructorTest extends LightCodeInsightFixtureTestCase { } public void testFieldPrefixCoincidence() { - CodeStyleSettingsManager.getInstance(getProject()).getCurrentSettings().FIELD_NAME_PREFIX = "m"; + getJavaSettings().FIELD_NAME_PREFIX = "m"; doTest(); } + @NotNull + private JavaCodeStyleSettings getJavaSettings() { + return CodeStyleSettingsManager.getInstance(getProject()).getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class); + } + public void testFieldPrefixCoincidence1() { - CodeStyleSettingsManager.getInstance(getProject()).getCurrentSettings().FIELD_NAME_PREFIX = "_"; + getJavaSettings().FIELD_NAME_PREFIX = "_"; doTest(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateEqualsTestCase.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateEqualsTestCase.java index 94d7f6bfe22c..4c4fc61d6d32 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateEqualsTestCase.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateEqualsTestCase.java @@ -22,6 +22,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiField; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.testFramework.LightCodeInsightTestCase; import com.intellij.util.Function; @@ -61,8 +62,8 @@ public abstract class GenerateEqualsTestCase extends LightCodeInsightTestCase { boolean insertOverride, boolean useAccessors) { CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); - settings.GENERATE_FINAL_LOCALS = true; - settings.INSERT_OVERRIDE_ANNOTATION = insertOverride; + settings.getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS = true; + settings.getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION = insertOverride; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); try { PsiElement element = getFile().findElementAt(getEditor().getCaretModel().getOffset()); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateGetterSetterTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateGetterSetterTest.groovy index 1908afb1f3c4..c419183740ae 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateGetterSetterTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/GenerateGetterSetterTest.groovy @@ -21,6 +21,7 @@ import com.intellij.codeInsight.generation.GenerateSetterHandler import com.intellij.openapi.editor.Editor import com.intellij.openapi.project.Project import com.intellij.psi.codeStyle.CodeStyleSettingsManager +import com.intellij.psi.codeStyle.JavaCodeStyleSettings import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase import com.intellij.util.ui.UIUtil import com.siyeh.ig.style.UnqualifiedFieldAccessInspection @@ -98,7 +99,7 @@ class Foo { } void "test strip field prefix"() { - def settings = CodeStyleSettingsManager.getInstance(getProject()).currentSettings + def settings = CodeStyleSettingsManager.getInstance(getProject()).currentSettings.getCustomSettings(JavaCodeStyleSettings.class) String oldPrefix = settings.FIELD_NAME_PREFIX try { settings.FIELD_NAME_PREFIX = "my" diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/OverrideImplement15Test.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/OverrideImplement15Test.java index 64bb789552a5..890bd6876c6d 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/OverrideImplement15Test.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/OverrideImplement15Test.java @@ -27,6 +27,7 @@ import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.MethodSignature; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.TypeConversionUtil; @@ -79,7 +80,7 @@ public class OverrideImplement15Test extends LightCodeInsightTestCase { CommonCodeStyleSettings javaSettings = codeStyleSettings.getCommonSettings(JavaLanguage.INSTANCE); javaSettings.RIGHT_MARGIN = 80; javaSettings.KEEP_LINE_BREAKS = true; - codeStyleSettings.GENERATE_FINAL_PARAMETERS = true; + codeStyleSettings.getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS = true; javaSettings.METHOD_PARAMETERS_WRAP = CommonCodeStyleSettings.WRAP_ON_EVERY_ITEM; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(codeStyleSettings); doTest(false); @@ -92,7 +93,7 @@ public class OverrideImplement15Test extends LightCodeInsightTestCase { public void testOverridingLibraryFunctionWithConfiguredParameterPrefix() throws Exception { CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(getProject()).clone(); try { - codeStyleSettings.PARAMETER_NAME_PREFIX = "in"; + codeStyleSettings.getCustomSettings(JavaCodeStyleSettings.class).PARAMETER_NAME_PREFIX = "in"; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(codeStyleSettings); doTest(false); } @@ -107,7 +108,7 @@ public class OverrideImplement15Test extends LightCodeInsightTestCase { CommonCodeStyleSettings javaSettings = codeStyleSettings.getCommonSettings(JavaLanguage.INSTANCE); javaSettings.RIGHT_MARGIN = 80; javaSettings.KEEP_LINE_BREAKS = false; - codeStyleSettings.GENERATE_FINAL_PARAMETERS = false; + codeStyleSettings.getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS = false; javaSettings.METHOD_PARAMETERS_WRAP = CommonCodeStyleSettings.WRAP_ON_EVERY_ITEM; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(codeStyleSettings); doTest(false); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/SuppressExternalTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/SuppressExternalTest.java index 6c3ef59bafdb..2c61aaed0117 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/SuppressExternalTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/SuppressExternalTest.java @@ -30,6 +30,7 @@ import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.testFramework.UsefulTestCase; import com.intellij.testFramework.builders.JavaModuleFixtureBuilder; import com.intellij.testFramework.fixtures.*; @@ -93,13 +94,14 @@ public class SuppressExternalTest extends UsefulTestCase { final IntentionAction action = myFixture.getAvailableIntention("Suppress for method", "src/suppressed/" + testName + ".java"); assertNotNull(action); Project project = myFixture.getProject(); - boolean oldUseExternalAnnotations = CodeStyleSettingsManager.getSettings(project).USE_EXTERNAL_ANNOTATIONS; + JavaCodeStyleSettings javaSettings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class); + boolean oldUseExternalAnnotations = javaSettings.USE_EXTERNAL_ANNOTATIONS; try { - CodeStyleSettingsManager.getSettings(project).USE_EXTERNAL_ANNOTATIONS = true; + javaSettings.USE_EXTERNAL_ANNOTATIONS = true; myFixture.launchAction(action); } finally { - CodeStyleSettingsManager.getSettings(project).USE_EXTERNAL_ANNOTATIONS = oldUseExternalAnnotations; + javaSettings.USE_EXTERNAL_ANNOTATIONS = oldUseExternalAnnotations; } myFixture.checkResultByFile("content/anno/suppressed/annotations.xml", "content/anno/suppressed/annotations" + testName + "_after.xml", true); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy index 2e83d48bcd4c..6188f66833de 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy @@ -33,6 +33,7 @@ import com.intellij.psi.PsiDocumentManager import com.intellij.psi.PsiMethod import com.intellij.psi.codeStyle.CodeStyleSettingsManager import com.intellij.psi.codeStyle.CommonCodeStyleSettings +import com.intellij.psi.codeStyle.JavaCodeStyleSettings import com.intellij.psi.impl.PsiDocumentManagerBase import com.intellij.util.ui.UIUtil import com.siyeh.ig.style.UnqualifiedFieldAccessInspection @@ -171,7 +172,7 @@ class NormalCompletionTest extends LightFixtureCompletionTestCase { LookupManager.getInstance(getProject()).hideActiveLookup() - CodeStyleSettingsManager.getSettings(getProject()).PREFER_LONGER_NAMES = false + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).PREFER_LONGER_NAMES = false try{ configureByFile("PreferLongerNamesOption.java") @@ -181,7 +182,7 @@ class NormalCompletionTest extends LightFixtureCompletionTestCase { assertEquals("abcdEfghIjk", myItems[2].getLookupString()) } finally{ - CodeStyleSettingsManager.getSettings(getProject()).PREFER_LONGER_NAMES = true + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).PREFER_LONGER_NAMES = true } } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java index 907207497a9d..72f806fd40c4 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java @@ -17,9 +17,9 @@ import com.intellij.codeInsight.template.TemplateManager; import com.intellij.codeInsight.template.impl.TemplateImpl; import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.fileEditor.FileDocumentManager; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.testFramework.fixtures.CodeInsightTestUtil; import com.intellij.util.containers.ContainerUtil; @@ -833,7 +833,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } public void testInsertOverride() throws Exception { - CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(getProject()); + JavaCodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); styleSettings.INSERT_OVERRIDE_ANNOTATION = true; doItemTest(); } @@ -1119,13 +1119,14 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } public void testInnerClassImports() throws Throwable { - CodeStyleSettingsManager.getSettings(getProject()).INSERT_INNER_CLASS_IMPORTS = true; + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); + settings.INSERT_INNER_CLASS_IMPORTS = true; try { myFixture.addClass("package java.awt.geom; public class Point2D { public static class Double {} }"); doActionTest(); } finally { - CodeStyleSettingsManager.getSettings(getProject()).INSERT_INNER_CLASS_IMPORTS = false; + settings.INSERT_INNER_CLASS_IMPORTS = false; } } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy index 63d377944e93..c15236ad7310 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy @@ -14,11 +14,12 @@ * limitations under the License. */ package com.intellij.java.codeInsight.completion + import com.intellij.JavaTestUtil import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase import com.intellij.ide.highlighter.JavaFileType -import com.intellij.psi.codeStyle.CodeStyleSettings import com.intellij.psi.codeStyle.CodeStyleSettingsManager +import com.intellij.psi.codeStyle.JavaCodeStyleSettings class VariablesCompletionTest extends LightFixtureCompletionTestCase { public static final String FILE_PREFIX = "/codeInsight/completion/variables/" @@ -119,7 +120,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { } void testFieldNameCompletion1() throws Exception { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()) + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class) String oldPrefix = settings.FIELD_NAME_PREFIX settings.FIELD_NAME_PREFIX = "my" try { @@ -131,7 +132,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { } void testFieldNameCompletion2() throws Exception { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project) + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class) String oldPrefix = settings.FIELD_NAME_PREFIX settings.FIELD_NAME_PREFIX = "my" configureByFile(FILE_PREFIX + "locals/" + "FieldNameCompletion2.java") @@ -140,7 +141,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { } void testFieldNameCompletion3() throws Exception { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project) + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class) String oldPrefix = settings.FIELD_NAME_PREFIX settings.FIELD_NAME_PREFIX = "my" configureByFile(FILE_PREFIX + "locals/" + "FieldNameCompletion3.java") @@ -214,7 +215,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { } void testConstructorParameterNameWithPrefix() { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project) + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class) String oldField = settings.FIELD_NAME_PREFIX String oldParam = settings.PARAMETER_NAME_PREFIX settings.FIELD_NAME_PREFIX = "my" diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/ImportHelperTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/ImportHelperTest.java index 79130b9c448e..2c315cd8115b 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/ImportHelperTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/ImportHelperTest.java @@ -59,7 +59,7 @@ public class ImportHelperTest extends DaemonAnalyzerTestCase { protected void setUp() throws Exception { super.setUp(); CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); - settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 100; + settings.getCustomSettings(JavaCodeStyleSettings.class).CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 100; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); DaemonCodeAnalyzer.getInstance(getProject()).setUpdateByTimerEnabled(false); } @@ -130,7 +130,8 @@ public class ImportHelperTest extends DaemonAnalyzerTestCase { try { CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); - settings.LAYOUT_STATIC_IMPORTS_SEPARATELY = true; + JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); + javaSettings.LAYOUT_STATIC_IMPORTS_SEPARATELY = true; PackageEntryTable table = new PackageEntryTable(); table.addEntry(PackageEntry.ALL_OTHER_IMPORTS_ENTRY); table.addEntry(PackageEntry.BLANK_LINE_ENTRY); @@ -141,7 +142,7 @@ public class ImportHelperTest extends DaemonAnalyzerTestCase { table.addEntry(PackageEntry.BLANK_LINE_ENTRY); table.addEntry(PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY); - settings.IMPORT_LAYOUT_TABLE.copyFrom(table); + settings.getCustomSettings(JavaCodeStyleSettings.class).IMPORT_LAYOUT_TABLE.copyFrom(table); CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); JavaCodeStyleManager.getInstance(getProject()).optimizeImports(file); @@ -184,7 +185,7 @@ public class ImportHelperTest extends DaemonAnalyzerTestCase { assertEmpty(highlightErrors()); CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); - settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 2; + settings.getCustomSettings(JavaCodeStyleSettings.class).CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 2; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); WriteCommandAction.runWriteCommandAction(getProject(), () -> JavaCodeStyleManager.getInstance(getProject()).optimizeImports(getFile())); @@ -477,9 +478,10 @@ public class ImportHelperTest extends DaemonAnalyzerTestCase { assertEmpty(highlightErrors()); CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); - settings.LAYOUT_STATIC_IMPORTS_SEPARATELY = true; - settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 3; - settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = 3; + JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); + javaSettings.LAYOUT_STATIC_IMPORTS_SEPARATELY = true; + javaSettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 3; + javaSettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = 3; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); WriteCommandAction.runWriteCommandAction(getProject(), () -> JavaCodeStyleManager.getInstance(getProject()).optimizeImports(getFile())); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/AssignFieldFromParameterTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/AssignFieldFromParameterTest.java index bdb74e546b72..6a83e91326e6 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/AssignFieldFromParameterTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/AssignFieldFromParameterTest.java @@ -18,6 +18,7 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.LightIntentionActionTestCase; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import org.jdom.Element; /** @@ -32,8 +33,8 @@ public class AssignFieldFromParameterTest extends LightIntentionActionTestCase { CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); myOldSettings = new Element("dummy2"); settings.writeExternal(myOldSettings); - settings.FIELD_NAME_PREFIX = "my"; - settings.STATIC_FIELD_NAME_PREFIX = "our"; + settings.getCustomSettings(JavaCodeStyleSettings.class).FIELD_NAME_PREFIX = "my"; + settings.getCustomSettings(JavaCodeStyleSettings.class).STATIC_FIELD_NAME_PREFIX = "our"; } @Override diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/BindFieldsFromParametersTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/BindFieldsFromParametersTest.java index 43a5be0f2f08..cf2cdb1ff2f5 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/BindFieldsFromParametersTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/BindFieldsFromParametersTest.java @@ -16,8 +16,8 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.LightIntentionActionTestCase; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; /** * @author Danila Ponomarenko @@ -28,7 +28,7 @@ public class BindFieldsFromParametersTest extends LightIntentionActionTestCase { @Override protected void setUp() throws Exception { super.setUp(); - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); settings.FIELD_NAME_PREFIX = "my"; myPreferLongNames = settings.PREFER_LONGER_NAMES; if (getTestName(false).contains("SameParam")) { @@ -38,7 +38,7 @@ public class BindFieldsFromParametersTest extends LightIntentionActionTestCase { @Override protected void tearDown() throws Exception { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); settings.FIELD_NAME_PREFIX = ""; settings.PREFER_LONGER_NAMES = myPreferLongNames; super.tearDown(); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateConstructorParameterFromFieldTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateConstructorParameterFromFieldTest.java index cb633620717d..22ffd4dab71e 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateConstructorParameterFromFieldTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateConstructorParameterFromFieldTest.java @@ -17,8 +17,8 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; import com.intellij.codeInspection.deadCode.UnusedDeclarationInspection; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.siyeh.ig.style.MissortedModifiersInspection; import com.siyeh.ig.style.UnqualifiedFieldAccessInspection; @@ -33,7 +33,7 @@ public class CreateConstructorParameterFromFieldTest extends LightQuickFixParame protected void setUp() throws Exception { super.setUp(); enableInspectionTools(new UnusedDeclarationInspection(), new MissortedModifiersInspection(), new UnqualifiedFieldAccessInspection()); - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); myPreferLongNames = settings.PREFER_LONGER_NAMES; if (getTestName(false).contains("SameParameter")) { settings.PREFER_LONGER_NAMES = false; @@ -42,7 +42,7 @@ public class CreateConstructorParameterFromFieldTest extends LightQuickFixParame @Override protected void tearDown() throws Exception { - CodeStyleSettingsManager.getSettings(getProject()).PREFER_LONGER_NAMES = myPreferLongNames; + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).PREFER_LONGER_NAMES = myPreferLongNames; super.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateFieldFromParameterTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateFieldFromParameterTest.java index 606be5f00ed0..6852df4bbc58 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateFieldFromParameterTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateFieldFromParameterTest.java @@ -17,6 +17,7 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.LightIntentionActionTestCase; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; /** * @author ven @@ -25,12 +26,12 @@ public class CreateFieldFromParameterTest extends LightIntentionActionTestCase { @Override protected void setUp() throws Exception { super.setUp(); - CodeStyleSettingsManager.getSettings(getProject()).FIELD_NAME_PREFIX = "my"; + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).FIELD_NAME_PREFIX = "my"; } @Override protected void tearDown() throws Exception { - CodeStyleSettingsManager.getSettings(getProject()).FIELD_NAME_PREFIX = ""; + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).FIELD_NAME_PREFIX = ""; //noinspection SuperTearDownInFinally super.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateLocalFromUsageTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateLocalFromUsageTest.java index cdfbc75fc2d5..3f3e1addc712 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateLocalFromUsageTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/CreateLocalFromUsageTest.java @@ -17,6 +17,7 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; /** * @author ven @@ -26,12 +27,13 @@ public class CreateLocalFromUsageTest extends LightQuickFixParameterizedTestCase @Override protected void setUp() throws Exception { super.setUp(); - CodeStyleSettingsManager.getSettings(getProject()).GENERATE_FINAL_LOCALS = getTestName(true).contains("final"); + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS = + getTestName(true).contains("final"); } @Override protected void tearDown() throws Exception { - CodeStyleSettingsManager.getSettings(getProject()).GENERATE_FINAL_LOCALS = false; + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS = false; super.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/Lambda2MethodReferenceInspectionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/Lambda2MethodReferenceInspectionTest.java index 1e092cefcee9..f704a9b6fe8a 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/Lambda2MethodReferenceInspectionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/Lambda2MethodReferenceInspectionTest.java @@ -18,8 +18,8 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; import com.intellij.codeInspection.LambdaCanBeMethodReferenceInspection; import com.intellij.codeInspection.LocalInspectionTool; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import org.jetbrains.annotations.NotNull; @@ -27,14 +27,16 @@ public class Lambda2MethodReferenceInspectionTest extends LightQuickFixParameter @Override protected void setUp() throws Exception { super.setUp(); - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); - settings.REPLACE_CAST = settings.REPLACE_INSTANCEOF = true; + JavaCodeStyleSettings javaSettings = + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); + javaSettings.REPLACE_CAST = javaSettings.REPLACE_INSTANCEOF = true; } @Override protected void tearDown() throws Exception { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); - settings.REPLACE_CAST = settings.REPLACE_INSTANCEOF = false; + JavaCodeStyleSettings javaSettings = + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); + javaSettings.REPLACE_CAST = javaSettings.REPLACE_INSTANCEOF = false; super.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/ReplaceIteratorForEachLoopWithIteratorForLoopFixTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/ReplaceIteratorForEachLoopWithIteratorForLoopFixTest.java index 6afd4946543b..180e7db5af86 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/ReplaceIteratorForEachLoopWithIteratorForLoopFixTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/quickFix/ReplaceIteratorForEachLoopWithIteratorForLoopFixTest.java @@ -18,6 +18,7 @@ package com.intellij.java.codeInsight.daemon.quickFix; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; /** * @author Pavel.Dolgov @@ -32,7 +33,8 @@ public class ReplaceIteratorForEachLoopWithIteratorForLoopFixTest extends LightQ protected void setUp() throws Exception { super.setUp(); if (getTestName(false).startsWith("Final")) { - final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings codeStyleSettings = + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); myFinalLocals = codeStyleSettings.GENERATE_FINAL_LOCALS; codeStyleSettings.GENERATE_FINAL_LOCALS = true; } @@ -43,7 +45,7 @@ public class ReplaceIteratorForEachLoopWithIteratorForLoopFixTest extends LightQ try { if (getTestName(false).startsWith("Final")) { final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(getProject()); - codeStyleSettings.GENERATE_FINAL_LOCALS = myFinalLocals; + codeStyleSettings.getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS = myFinalLocals; } } finally { diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/AddSingleStaticImportActionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/AddSingleStaticImportActionTest.java index 357793692432..756f95907500 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/AddSingleStaticImportActionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/AddSingleStaticImportActionTest.java @@ -17,8 +17,8 @@ package com.intellij.java.codeInsight.intention; import com.intellij.JavaTestUtil; import com.intellij.codeInsight.intention.IntentionAction; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase; public class AddSingleStaticImportActionTest extends JavaCodeInsightFixtureTestCase { @@ -127,7 +127,7 @@ public class AddSingleStaticImportActionTest extends JavaCodeInsightFixtureTestC myFixture.addClass("package foo; class Bar {public static void foo(String s){}}"); myFixture.configureByFile(getTestName(false) + ".java"); - CodeStyleSettings settings = CodeStyleSettingsManager.getInstance(getProject()).getCurrentSettings(); + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getInstance(getProject()).getCurrentSettings().getCustomSettings(JavaCodeStyleSettings.class); int old = settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND; settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = 1; try { diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/CopyAbstractMethodImplementationTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/CopyAbstractMethodImplementationTest.java index ed2643c3a8be..b4a3bba6ca61 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/CopyAbstractMethodImplementationTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/CopyAbstractMethodImplementationTest.java @@ -19,6 +19,7 @@ import com.intellij.codeInsight.daemon.LightIntentionActionTestCase; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; /** * @author yole @@ -33,7 +34,7 @@ public class CopyAbstractMethodImplementationTest extends LightIntentionActionTe protected void setUp() throws Exception { super.setUp(); CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); - settings.INSERT_OVERRIDE_ANNOTATION = false; + settings.getCustomSettings(JavaCodeStyleSettings.class).INSERT_OVERRIDE_ANNOTATION = false; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/template/postfix/templates/ForeachTemplateTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/template/postfix/templates/ForeachTemplateTest.java index a9e188228e2b..2632b9bbae4c 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/template/postfix/templates/ForeachTemplateTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/template/postfix/templates/ForeachTemplateTest.java @@ -15,8 +15,8 @@ */ package com.intellij.java.codeInsight.template.postfix.templates; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import org.jetbrains.annotations.NotNull; public class ForeachTemplateTest extends PostfixTemplateTestCase { @@ -43,7 +43,7 @@ public class ForeachTemplateTest extends PostfixTemplateTestCase { } public void testFinalLocals() { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); boolean oldGenerateFinalLocals = settings.GENERATE_FINAL_LOCALS; try { settings.GENERATE_FINAL_LOCALS = true; diff --git a/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavaFormatterTest.java b/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavaFormatterTest.java index 2f76f8939d24..76396e024022 100644 --- a/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavaFormatterTest.java +++ b/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavaFormatterTest.java @@ -1155,7 +1155,7 @@ public class JavaFormatterTest extends AbstractJavaFormatterTest { } public void testJavaDocLeadingAsterisksAreDisabled() throws Exception { - getSettings().getRootSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = false; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = false; doTextTest("class Foo {\n" + " /**\n" + " @param i\n" + @@ -1298,7 +1298,7 @@ public class JavaFormatterTest extends AbstractJavaFormatterTest { getSettings().getRootSettings().getIndentOptions(StdFileTypes.JAVA).CONTINUATION_INDENT_SIZE = 2; getSettings().getRootSettings().getIndentOptions(StdFileTypes.JAVA).TAB_SIZE = 4; - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = false; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = false; doTextTest("public interface PsiParser {\n" + " /**\n" + @@ -1750,7 +1750,7 @@ public class JavaFormatterTest extends AbstractJavaFormatterTest { } public void testFormatComments() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; doTextTest("public class Test {\n" + "\n" + " /**\n" + " * The s property.\n" + " */\n" + " private String s;\n" + "}", "public class Test {\n" + "\n" + " /**\n" + " * The s property.\n" + " */\n" + " private String s;\n" + "}"); @@ -2789,7 +2789,7 @@ public void testSCR260() throws Exception { } public void testIDEADEV_6239() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; doTextTest("public class Test {\n" + "\n" + " /**\n" + diff --git a/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavadocFormatterTest.java b/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavadocFormatterTest.java index 8dcaec2402b5..9cd71b5f3ace 100644 --- a/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavadocFormatterTest.java +++ b/java/java-tests/testSrc/com/intellij/java/psi/formatter/java/JavadocFormatterTest.java @@ -197,8 +197,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testOneLineCommentWrappedByRightMarginIntoMultiLine() throws Exception { getSettings().getRootSettings().WRAP_COMMENTS = true; - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; - getSettings().getRootSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; getSettings().RIGHT_MARGIN = 35; doTextTest( "/** Here is one-line java-doc comment */" + @@ -215,7 +215,7 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testLineFeedsArePreservedDuringWrap() { // Inspired by IDEA-61895 getSettings().getRootSettings().WRAP_COMMENTS = true; - getSettings().getRootSettings().JD_PRESERVE_LINE_FEEDS = true; + getJavaSettings().JD_PRESERVE_LINE_FEEDS = true; getSettings().RIGHT_MARGIN = 48; doTextTest( @@ -239,14 +239,14 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { final CommonCodeStyleSettings settings = getSettings(); settings.RIGHT_MARGIN = 50; settings.getRootSettings().WRAP_COMMENTS = true; - settings.getRootSettings().ENABLE_JAVADOC_FORMATTING = true; - settings.getRootSettings().JD_P_AT_EMPTY_LINES = false; - settings.getRootSettings().JD_KEEP_EMPTY_LINES = false; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_P_AT_EMPTY_LINES = false; + getJavaSettings().JD_KEEP_EMPTY_LINES = false; doTest(); } public void testSCR2632() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().getRootSettings().WRAP_COMMENTS = true; getSettings().RIGHT_MARGIN = 20; doTextTest("/**\n" + @@ -266,7 +266,7 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void test_PreserveExistingSelfClosingTags_AndGenerateOnlyPTag() { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; LanguageLevel before = LanguageLevelProjectExtension.getInstance(getProject()).getLanguageLevel(); LanguageLevelProjectExtension.getInstance(getProject()).setLanguageLevel(LanguageLevel.JDK_1_7); try { @@ -296,8 +296,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testParagraphTagGeneration() { // Inspired by IDEA-61811 - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; - getSettings().getRootSettings().JD_P_AT_EMPTY_LINES = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_P_AT_EMPTY_LINES = true; LanguageLevelProjectExtension.getInstance(getProject()).setLanguageLevel(LanguageLevel.JDK_1_7); doTextTest( "/**\n" + @@ -329,8 +329,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testParameterDescriptionNotOnNewLine() throws Exception { // IDEA-107383 - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; - getSettings().getRootSettings().JD_ALIGN_PARAM_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_ALIGN_PARAM_COMMENTS = true; doClassTest( "/**\n" + @@ -353,9 +353,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testWrappedParameterDescription() throws Exception { // Inspired by IDEA-13072 - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().getRootSettings().WRAP_COMMENTS = true; - getSettings().getRootSettings().JD_PARAM_DESCRIPTION_ON_NEW_LINE = true; + getJavaSettings().JD_PARAM_DESCRIPTION_ON_NEW_LINE = true; doClassTest( "/**\n" + " * test description\n" + @@ -385,8 +385,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testExceptionAlignmentCorrect() { - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; - getCurrentCodeStyleSettings().JD_ALIGN_EXCEPTION_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_ALIGN_EXCEPTION_COMMENTS = true; String before = "public class Controller {\n" + @@ -422,8 +422,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testDoNotWrapMultiLineCommentIntoOneLine() throws Exception { - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; - getCurrentCodeStyleSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; String test = "/**\n" + " * foo\n" + " */\n" + @@ -434,8 +434,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testLeaveOneLineComment() throws Exception { - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; - getCurrentCodeStyleSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; String test = "/** foo */\n" + "public Object next() {\n" + " return new Object();\n" + @@ -444,8 +444,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testWrapOneLineComment() throws Exception { - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; - getCurrentCodeStyleSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = false; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = false; String test = "/** foo */\n" + "public Object next() {\n" + " return new Object();\n" + @@ -460,8 +460,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testWrapStrangeComment() throws Exception { - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; - getCurrentCodeStyleSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = false; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = false; String test = "/** foo" + " */\n" + "public Object next() {\n" + @@ -477,8 +477,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testWrapStrangeCommentIfNotWrapOneLines() throws Exception { - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; - getCurrentCodeStyleSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; String test = "/** foo\n" + " */" + "public Object next() {\n" + @@ -495,9 +495,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testReturnTagAlignment() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().RIGHT_MARGIN = 80; - getSettings().getRootSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; getSettings().getRootSettings().WRAP_COMMENTS = true; getSettings().getRootSettings().getCommonSettings(JavaLanguage.INSTANCE).WRAP_LONG_LINES = true; @@ -523,9 +523,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testReturnTagAlignmentWithPreTagOnFirstLine() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().RIGHT_MARGIN = 80; - getSettings().getRootSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; getSettings().getRootSettings().WRAP_COMMENTS = true; getSettings().getRootSettings().getCommonSettings(JavaLanguage.INSTANCE).WRAP_LONG_LINES = true; @@ -550,8 +550,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testDoNotMergeCommentLines() { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; - getSettings().getRootSettings().JD_PRESERVE_LINE_FEEDS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_PRESERVE_LINE_FEEDS = true; getSettings().getRootSettings().WRAP_COMMENTS = true; doClassTest( @@ -575,9 +575,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testSeeTagAlignment() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().RIGHT_MARGIN = 80; - getSettings().getRootSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; getSettings().getRootSettings().WRAP_COMMENTS = true; getSettings().getRootSettings().getCommonSettings(JavaLanguage.INSTANCE).WRAP_LONG_LINES = true; @@ -602,9 +602,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testDummySinceTagAlignment() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().RIGHT_MARGIN = 80; - getSettings().getRootSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; getSettings().getRootSettings().WRAP_COMMENTS = true; getSettings().getRootSettings().getCommonSettings(JavaLanguage.INSTANCE).WRAP_LONG_LINES = true; @@ -629,9 +629,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testDummyDeprecatedTagAlignment() throws Exception { - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getSettings().RIGHT_MARGIN = 80; - getSettings().getRootSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; getSettings().getRootSettings().WRAP_COMMENTS = true; getSettings().getRootSettings().getCommonSettings(JavaLanguage.INSTANCE).WRAP_LONG_LINES = true; @@ -657,12 +657,12 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testJavadocFormattingIndependentOfMethodIndentation() { getCurrentCodeStyleSettings().setRightMargin(JavaLanguage.INSTANCE, 50); - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getCurrentCodeStyleSettings().WRAP_COMMENTS = true; - getCurrentCodeStyleSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; - getCurrentCodeStyleSettings().JD_P_AT_EMPTY_LINES = false; - getCurrentCodeStyleSettings().JD_KEEP_EMPTY_LINES = false; - getCurrentCodeStyleSettings().JD_ADD_BLANK_AFTER_DESCRIPTION = false; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_P_AT_EMPTY_LINES = false; + getJavaSettings().JD_KEEP_EMPTY_LINES = false; + getJavaSettings().JD_ADD_BLANK_AFTER_DESCRIPTION = false; String before1 = "class A {\n" + " /**\n" + " * Some really great independent test approach purpose live fish\n" + @@ -696,9 +696,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testJavadocAlignmentForInnerClasses() { getCurrentCodeStyleSettings().setRightMargin(JavaLanguage.INSTANCE, 40); - getCurrentCodeStyleSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; getCurrentCodeStyleSettings().WRAP_COMMENTS = true; - getCurrentCodeStyleSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; String code = "public class Outer {\n" + " class Inner {\n" + @@ -747,7 +747,7 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testAlignmentWithNoTopClassMembersIndentation() { getCurrentCodeStyleSettings().setRightMargin(JavaLanguage.INSTANCE, 40); getCurrentCodeStyleSettings().WRAP_COMMENTS = true; - getCurrentCodeStyleSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; + getJavaSettings().JD_LEADING_ASTERISKS_ARE_ENABLED = true; getCurrentCodeStyleSettings().getCommonSettings(JavaLanguage.INSTANCE).DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS = true; String before = "public class Outer {\n" + @@ -833,8 +833,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { public void testNotGenerateSelfClosingPTagIfLanguageLevelJava8() throws Exception { - getSettings().getRootSettings().JD_P_AT_EMPTY_LINES = true; - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_P_AT_EMPTY_LINES = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; String before = "/**\n" + " * Super method\n" + " *\n" + @@ -853,8 +853,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void testPTagIfLanguageLevelNotJava8() throws Exception { - getSettings().getRootSettings().JD_P_AT_EMPTY_LINES = true; - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_P_AT_EMPTY_LINES = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; LanguageLevelProjectExtension.getInstance(getProject()).setLanguageLevel(LanguageLevel.JDK_1_7); String before = "/**\n" + " * Super method\n" + @@ -874,8 +874,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void test_DoNotTouch_SingleLineComments() { - getSettings().getRootSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_DO_NOT_WRAP_ONE_LINE_COMMENTS = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; doClassTest( "/****** AAAAAAA *******/\n" + @@ -890,8 +890,8 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { } public void test_Keep_P_Tags() { - getSettings().getRootSettings().JD_P_AT_EMPTY_LINES = true; - getSettings().getRootSettings().ENABLE_JAVADOC_FORMATTING = true; + getJavaSettings().JD_P_AT_EMPTY_LINES = true; + getJavaSettings().ENABLE_JAVADOC_FORMATTING = true; doClassTest( "/**\n" + @@ -945,9 +945,9 @@ public class JavadocFormatterTest extends AbstractJavaFormatterTest { getCurrentCodeStyleSettings().getIndentOptions(JavaFileType.INSTANCE).CONTINUATION_INDENT_SIZE = 2; - getCurrentCodeStyleSettings().JD_INDENT_ON_CONTINUATION = true; - getCurrentCodeStyleSettings().JD_ALIGN_PARAM_COMMENTS = false; - getCurrentCodeStyleSettings().JD_ALIGN_EXCEPTION_COMMENTS = false; + getJavaSettings().JD_INDENT_ON_CONTINUATION = true; + getJavaSettings().JD_ALIGN_PARAM_COMMENTS = false; + getJavaSettings().JD_ALIGN_EXCEPTION_COMMENTS = false; getCurrentCodeStyleSettings().WRAP_COMMENTS = true; doClassTest( diff --git a/java/java-tests/testSrc/com/intellij/java/psi/impl/source/tree/java/BindToGenericClassTest.java b/java/java-tests/testSrc/com/intellij/java/psi/impl/source/tree/java/BindToGenericClassTest.java index 026b15d6409b..bbd7bb64d325 100644 --- a/java/java-tests/testSrc/com/intellij/java/psi/impl/source/tree/java/BindToGenericClassTest.java +++ b/java/java-tests/testSrc/com/intellij/java/psi/impl/source/tree/java/BindToGenericClassTest.java @@ -19,6 +19,7 @@ import com.intellij.java.psi.GenericsTestCase; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.search.GlobalSearchScope; /** @@ -33,14 +34,14 @@ public class BindToGenericClassTest extends GenericsTestCase { setupGenericSampleClasses(); final CodeStyleSettings currentSettings = CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings(); - myOldFQNamesSetting = currentSettings.USE_FQ_CLASS_NAMES; - currentSettings.USE_FQ_CLASS_NAMES = true; + myOldFQNamesSetting = currentSettings.getCustomSettings(JavaCodeStyleSettings.class).USE_FQ_CLASS_NAMES; + currentSettings.getCustomSettings(JavaCodeStyleSettings.class).USE_FQ_CLASS_NAMES = true; } @Override protected void tearDown() throws Exception { final CodeStyleSettings currentSettings = CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings(); - currentSettings.USE_FQ_CLASS_NAMES = myOldFQNamesSetting; + currentSettings.getCustomSettings(JavaCodeStyleSettings.class).USE_FQ_CLASS_NAMES = myOldFQNamesSetting; super.tearDown(); } diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodObjectWithMultipleExitPointsTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodObjectWithMultipleExitPointsTest.java index b90718c0433f..940b8af05a00 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodObjectWithMultipleExitPointsTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodObjectWithMultipleExitPointsTest.java @@ -20,8 +20,8 @@ import com.intellij.JavaTestUtil; import com.intellij.codeInsight.CodeInsightUtil; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiExpression; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.refactoring.extractMethodObject.ExtractMethodObjectHandler; import com.intellij.refactoring.extractMethodObject.ExtractMethodObjectProcessor; import org.jetbrains.annotations.NotNull; @@ -165,7 +165,7 @@ public class ExtractMethodObjectWithMultipleExitPointsTest extends LightRefactor } private void doTestWithIdeaCodeStyleSettings() throws Exception { - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); String oldPrefix = settings.FIELD_NAME_PREFIX; settings.FIELD_NAME_PREFIX = "my"; boolean oldPrefer = settings.PREFER_LONGER_NAMES; diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodTest.java index a4125ba0cdc6..71d9b815d33c 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/ExtractMethodTest.java @@ -27,6 +27,7 @@ import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.refactoring.extractMethod.ExtractMethodHandler; @@ -266,7 +267,7 @@ public class ExtractMethodTest extends LightCodeInsightTestCase { } public void testFinalParamUsedInsideAnon() throws Exception { - CodeStyleSettingsManager.getSettings(getProject()).GENERATE_FINAL_PARAMETERS = false; + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS = false; doTestWithJava17(); } @@ -283,7 +284,7 @@ public class ExtractMethodTest extends LightCodeInsightTestCase { } public void testNonFinalWritableParam() throws Exception { - CodeStyleSettingsManager.getSettings(getProject()).GENERATE_FINAL_PARAMETERS = true; + CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_PARAMETERS = true; doTest(); } @@ -547,7 +548,7 @@ public class ExtractMethodTest extends LightCodeInsightTestCase { } public void testReassignedVarAfterCall() throws Exception { - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); boolean oldGenerateFinalLocals = settings.GENERATE_FINAL_LOCALS; try { settings.GENERATE_FINAL_LOCALS = true; @@ -862,7 +863,7 @@ public class ExtractMethodTest extends LightCodeInsightTestCase { } public void testDefaultNamesConflictResolution() throws Exception { - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); final String oldPrefix = settings.LOCAL_VARIABLE_NAME_PREFIX; try { settings.LOCAL_VARIABLE_NAME_PREFIX = "_"; diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/InplaceIntroduceVariableTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/InplaceIntroduceVariableTest.java index e82c0be12172..7d985fc92614 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/InplaceIntroduceVariableTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/InplaceIntroduceVariableTest.java @@ -26,8 +26,8 @@ import com.intellij.openapi.util.Pass; import com.intellij.psi.PsiExpression; import com.intellij.psi.PsiLiteralExpression; import com.intellij.psi.PsiLocalVariable; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.refactoring.introduce.inplace.AbstractInplaceIntroducer; @@ -63,7 +63,7 @@ public class InplaceIntroduceVariableTest extends AbstractJavaInplaceIntroduceTe } public void testConflictingInnerClassName() throws Exception { - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); final boolean oldOption = settings.INSERT_INNER_CLASS_IMPORTS; try { settings.INSERT_INNER_CLASS_IMPORTS = true; diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/MakeClassStaticTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/MakeClassStaticTest.java index a1cf8c9afa59..d279c616b883 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/MakeClassStaticTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/MakeClassStaticTest.java @@ -19,8 +19,8 @@ import com.intellij.JavaTestUtil; import com.intellij.codeInsight.TargetElementUtil; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.refactoring.makeStatic.MakeClassStaticProcessor; import com.intellij.refactoring.makeStatic.MakeStaticUtil; import com.intellij.refactoring.makeStatic.Settings; @@ -64,7 +64,7 @@ public class MakeClassStaticTest extends LightRefactoringTestCase { } public void testFieldWithMyPrefix() throws Exception { - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); String oldPrefix = settings.FIELD_NAME_PREFIX; settings.FIELD_NAME_PREFIX = "my"; try { diff --git a/java/java-tests/testSrc/com/intellij/java/refactoring/MoveClassToInnerTest.java b/java/java-tests/testSrc/com/intellij/java/refactoring/MoveClassToInnerTest.java index 919738985f63..56c22b687548 100644 --- a/java/java-tests/testSrc/com/intellij/java/refactoring/MoveClassToInnerTest.java +++ b/java/java-tests/testSrc/com/intellij/java/refactoring/MoveClassToInnerTest.java @@ -23,6 +23,7 @@ import com.intellij.psi.PsiClass; import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiElement; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.source.PostprocessReformattingAspect; import com.intellij.psi.search.ProjectScope; import com.intellij.refactoring.RefactoringTestCase; @@ -56,13 +57,14 @@ public class MoveClassToInnerTest extends RefactoringTestCase { } public void testInsertInnerClassImport() throws Exception { - final boolean imports = CodeStyleSettingsManager.getSettings(myProject).INSERT_INNER_CLASS_IMPORTS; + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class); + final boolean imports = settings.INSERT_INNER_CLASS_IMPORTS; try { - CodeStyleSettingsManager.getSettings(myProject).INSERT_INNER_CLASS_IMPORTS = true; + settings.INSERT_INNER_CLASS_IMPORTS = true; doTest(new String[] { "pack1.Class1" }, "pack2.A"); } finally { - CodeStyleSettingsManager.getSettings(myProject).INSERT_INNER_CLASS_IMPORTS = imports; + settings.INSERT_INNER_CLASS_IMPORTS = imports; } } diff --git a/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java b/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java index ca7e89128d00..2602f1a4972d 100644 --- a/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java +++ b/java/typeMigration/src/com/intellij/refactoring/typeMigration/intentions/ConvertFieldToAtomicIntention.java @@ -12,6 +12,7 @@ import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleManager; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.JavaCodeStyleManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.AllowedApiFilterExtension; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiUtil; @@ -134,7 +135,7 @@ public class ConvertFieldToAtomicIntention extends PsiElementBaseIntentionAction static void postProcessVariable(@NotNull PsiVariable var, @NotNull String toType) { Project project = var.getProject(); - if (var instanceof PsiField || CodeStyleSettingsManager.getSettings(project).GENERATE_FINAL_LOCALS) { + if (var instanceof PsiField || CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class).GENERATE_FINAL_LOCALS) { PsiModifierList modifierList = assertNotNull(var.getModifierList()); WriteAction.run(() -> { if (var.getInitializer() == null) { diff --git a/platform/configuration-store-impl/testSrc/CodeStyleTest.kt b/platform/configuration-store-impl/testSrc/CodeStyleTest.kt index b862cc2c417c..445b9d829ac8 100644 --- a/platform/configuration-store-impl/testSrc/CodeStyleTest.kt +++ b/platform/configuration-store-impl/testSrc/CodeStyleTest.kt @@ -26,7 +26,7 @@ class CodeStyleTest { @Test fun `do not remove unknown`() { val settings = CodeStyleSettings() val loaded = """ - + @@ -105,7 +105,7 @@ class CodeStyleTest { val settings = CodeStyleSettings() val text : (param: String) -> String = { param -> """ - + @@ -136,4 +136,24 @@ class CodeStyleTest { Disposer.dispose(disposable) } } + + @Test fun `reset deprecations`() { + val settings = CodeStyleSettings() + val initial = """ + + """.trimIndent() + val expected = """ + + """.trimIndent(); + + settings.readExternal(loadElement(initial)) + settings.resetDeprecatedFields() + + val serialized = Element("code_scheme").setAttribute("name", "testSchemeName") + settings.writeExternal(serialized) + assertThat(JDOMUtil.writeElement(serialized)).isEqualTo(expected) + } } \ No newline at end of file diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleScheme.java b/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleScheme.java index ac2e24e68c91..378962171a36 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleScheme.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleScheme.java @@ -22,6 +22,9 @@ public interface CodeStyleScheme extends Scheme { String DEFAULT_SCHEME_NAME = "Default"; String PROJECT_SCHEME_NAME = "Project"; + String CODE_STYLE_TAG_NAME = "code_scheme"; + String CODE_STYLE_NAME_ATTR = "name"; + @Override @NotNull String getName(); diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettings.java b/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettings.java index 0c505981fc77..e059584cdb83 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettings.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettings.java @@ -45,14 +45,18 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; import javax.swing.*; +import java.lang.reflect.Field; import java.util.*; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; public class CodeStyleSettings extends CommonCodeStyleSettings implements Cloneable, JDOMExternalizable, ImportsLayoutSettings { + public static final int CURR_VERSION = 173; + public static final int MAX_RIGHT_MARGIN = 1000; private static final Logger LOG = Logger.getInstance(CodeStyleSettings.class); + public static final String VERSION_ATTR = "version"; private final ClassMap myCustomSettings = new ClassMap<>(); @@ -66,6 +70,8 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea private UnknownElementWriter myUnknownElementWriter = UnknownElementWriter.EMPTY; + private int myVersion = CURR_VERSION; + public CodeStyleSettings() { this(true); } @@ -187,13 +193,6 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea public boolean AUTODETECT_INDENTS = true; - @Deprecated - public final IndentOptions JAVA_INDENT_OPTIONS = new IndentOptions(); - @Deprecated - public final IndentOptions JSP_INDENT_OPTIONS = new IndentOptions(); - @Deprecated - public final IndentOptions XML_INDENT_OPTIONS = new IndentOptions(); - public final IndentOptions OTHER_INDENT_OPTIONS = new IndentOptions(); private final Map myAdditionalIndentOptions = new LinkedHashMap<>(); @@ -216,46 +215,90 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea // region Java settings (legacy) //----------------- NAMING CONVENTIONS -------------------- + /** @deprecated Use JavaCodeStyleSettings.FIELD_NAME_PREFIX */ + @Deprecated public String FIELD_NAME_PREFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.STATIC_FIELD_NAME_PREFIX */ + @Deprecated public String STATIC_FIELD_NAME_PREFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.PARAMETER_NAME_PREFIX */ + @Deprecated public String PARAMETER_NAME_PREFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.LOCAL_VARIABL_NAME_PREFIX */ + @Deprecated public String LOCAL_VARIABLE_NAME_PREFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.FIELD_NAME_SUFFIX */ + @Deprecated public String FIELD_NAME_SUFFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.STATIC_FIELD_NAME_SUFFIX */ + @Deprecated public String STATIC_FIELD_NAME_SUFFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.PARAMETER_NAME_SUFFIX */ + @Deprecated public String PARAMETER_NAME_SUFFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.LOCAL_VARIABLE_NAME_SUFFIX */ + @Deprecated public String LOCAL_VARIABLE_NAME_SUFFIX = ""; + /** @deprecated Use JavaCodeStyleSettings.PREFER_LONGER_NAMES */ + @Deprecated public boolean PREFER_LONGER_NAMES = true; + /** @deprecated Use JavaCodeStyleSettings.FILED_TYPE_TO_NAME */ + @Deprecated public final TypeToNameMap FIELD_TYPE_TO_NAME = new TypeToNameMap(); + /** @deprecated Use JavaCodeStyleSettings.STATIC_FIELD_TYPE_TO_NAME */ + @Deprecated public final TypeToNameMap STATIC_FIELD_TYPE_TO_NAME = new TypeToNameMap(); + /** @deprecated Use JavaCodeStyleSettings.PARAMETER_TYPE_TO_NAME */ + @Deprecated @NonNls public final TypeToNameMap PARAMETER_TYPE_TO_NAME = new TypeToNameMap(); + /** @deprecated Use JavaCodeStyleSettings.LOCAL_VARIABLE_TYPE_TO_NAME */ + @Deprecated public final TypeToNameMap LOCAL_VARIABLE_TYPE_TO_NAME = new TypeToNameMap(); //----------------- 'final' modifier settings ------- + /** @deprecated Use JavaCodeStyleSettings.GENERATE_FINAL_LOCALS */ + @Deprecated public boolean GENERATE_FINAL_LOCALS; + /** @deprecated Use JavaCodeStyleSettings.GENERATE_FINAL_PARAMETERS */ + @Deprecated public boolean GENERATE_FINAL_PARAMETERS; //----------------- visibility ----------------------------- + /** @deprecated Use JavaCodeStyleSettings.VISIBILITY */ + @Deprecated public String VISIBILITY = "public"; //----------------- generate parentheses around method arguments ---------- + /** @deprecated Use RubyCodeStyleSettings.PARENTHESES_AROUND_METHOD_ARGUMENTS */ + @Deprecated public boolean PARENTHESES_AROUND_METHOD_ARGUMENTS = true; //----------------- annotations ---------------- + /** @deprecated Use JavaCodeStyleSettings.USE_EXTERNAL_ANNOTATIONS */ + @Deprecated public boolean USE_EXTERNAL_ANNOTATIONS; + /** @deprecated Use JavaCodeStyleSettings.INSERT_OVERRIDE_ANNOTATIONS */ + @Deprecated public boolean INSERT_OVERRIDE_ANNOTATION = true; //----------------- override ------------------- + /** @deprecated Use JavaCodeStyleSettings.REPEAT_SYNCHRONIZED */ + @Deprecated public boolean REPEAT_SYNCHRONIZED = true; private List myRepeatAnnotations = new ArrayList<>(); + /** @deprecated Use JavaCodeStyleSettings.getRepeatAnnotations() */ + @Deprecated public List getRepeatAnnotations() { return myRepeatAnnotations; } + /** @deprecated Use JavaCodeStyleSettings.setRepeatAnnotations() */ + @Deprecated public void setRepeatAnnotations(List repeatAnnotations) { myRepeatAnnotations.clear(); myRepeatAnnotations.addAll(repeatAnnotations); @@ -263,91 +306,142 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea //----------------- FUNCTIONAL EXPRESSIONS ----- + /** @deprecated Use JavaCodeStyleSettings.REPLACE_INSTANCE_OF */ + @Deprecated public boolean REPLACE_INSTANCEOF = false; + /** @deprecated Use JavaCodeStyleSettings.REPLACE_CAST */ + @Deprecated public boolean REPLACE_CAST = false; + /** @deprecated Use JavaCodeStyleSettings.REPLACE_NULL_CHECK */ + @Deprecated public boolean REPLACE_NULL_CHECK = true; - //----------------- IMPORTS -------------------- + //----------------- JAVA IMPORTS (deprecated, moved to JavaCodeStyleSettings) -------------------- + /** @deprecated Use JavaCodeStyleSettings.LAYOUT_STATIC_IMPORTS_SEPARATELY */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public boolean LAYOUT_STATIC_IMPORTS_SEPARATELY = true; + + /** @deprecated Use JavaCodeStyleSettings.USE_FQ_CLASS_NAMES */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public boolean USE_FQ_CLASS_NAMES; /** @deprecated use com.intellij.psi.codeStyle.JavaCodeStyleSettings.CLASS_NAMES_IN_JAVADOC */ @Deprecated public boolean USE_FQ_CLASS_NAMES_IN_JAVADOC = true; + + /** @deprecated Use JavaCodeStyleSettings.USE_SINGLE_CLASS_IMPORTS */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public boolean USE_SINGLE_CLASS_IMPORTS = true; + + /** @deprecated Use JavaCodeStyleSettings.INSERT_INNER_CLASS_IMPORTS */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public boolean INSERT_INNER_CLASS_IMPORTS; + + /** @deprecated Use JavaCodeStyleSettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public int CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 5; + + /** @deprecated Use JavaCodeStyleSettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public int NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = 3; + + /** @deprecated Use JavaCodeStyleSettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public final PackageEntryTable PACKAGES_TO_USE_IMPORT_ON_DEMAND = new PackageEntryTable(); + + /** @deprecated Use JavaCodeStyleSettings.IMPORT_LAYOUT_TABLE */ + @SuppressWarnings("DeprecatedIsStillUsed") + @Deprecated public final PackageEntryTable IMPORT_LAYOUT_TABLE = new PackageEntryTable(); @Override + @Deprecated public boolean isLayoutStaticImportsSeparately() { return LAYOUT_STATIC_IMPORTS_SEPARATELY; } @Override + @Deprecated public void setLayoutStaticImportsSeparately(boolean value) { LAYOUT_STATIC_IMPORTS_SEPARATELY = value; } - + + @Deprecated @Override public int getNamesCountToUseImportOnDemand() { return NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND; } - + + @Deprecated @Override public void setNamesCountToUseImportOnDemand(int value) { NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = value; } + @Deprecated @Override public int getClassCountToUseImportOnDemand() { return CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND; } + @Deprecated @Override public void setClassCountToUseImportOnDemand(int value) { CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = value; } + @Deprecated @Override public boolean isInsertInnerClassImports() { return INSERT_INNER_CLASS_IMPORTS; } + @Deprecated @Override public void setInsertInnerClassImports(boolean value) { INSERT_INNER_CLASS_IMPORTS = value; } + @Deprecated @Override public boolean isUseSingleClassImports() { return USE_SINGLE_CLASS_IMPORTS; } + @Deprecated @Override public void setUseSingleClassImports(boolean value) { USE_SINGLE_CLASS_IMPORTS = value; } - + + @Deprecated @Override public boolean isUseFqClassNames() { return USE_FQ_CLASS_NAMES; } + @Deprecated @Override public void setUseFqClassNames(boolean value) { USE_FQ_CLASS_NAMES = value; } + @Deprecated @Override public PackageEntryTable getImportLayoutTable() { return IMPORT_LAYOUT_TABLE; } - + + @Deprecated @Override public PackageEntryTable getPackagesToUseImportOnDemand() { return PACKAGES_TO_USE_IMPORT_ON_DEMAND; @@ -357,13 +451,13 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea // region ORDER OF MEMBERS - public int STATIC_FIELDS_ORDER_WEIGHT = 1; - public int FIELDS_ORDER_WEIGHT = 2; - public int CONSTRUCTORS_ORDER_WEIGHT = 3; - public int STATIC_METHODS_ORDER_WEIGHT = 4; - public int METHODS_ORDER_WEIGHT = 5; - public int STATIC_INNER_CLASSES_ORDER_WEIGHT = 6; - public int INNER_CLASSES_ORDER_WEIGHT = 7; + @Deprecated public int STATIC_FIELDS_ORDER_WEIGHT = 1; + @Deprecated public int FIELDS_ORDER_WEIGHT = 2; + @Deprecated public int CONSTRUCTORS_ORDER_WEIGHT = 3; + @Deprecated public int STATIC_METHODS_ORDER_WEIGHT = 4; + @Deprecated public int METHODS_ORDER_WEIGHT = 5; + @Deprecated public int STATIC_INNER_CLASSES_ORDER_WEIGHT = 6; + @Deprecated public int INNER_CLASSES_ORDER_WEIGHT = 7; // endregion @@ -371,7 +465,7 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea /** * @deprecated Use get/setRightMargin() methods instead. */ - @Deprecated + @SuppressWarnings("DeprecatedIsStillUsed") public int RIGHT_MARGIN = 120; /** * Do not use this field directly since it doesn't reflect a setting for a specific language which may @@ -385,100 +479,108 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea // region Javadoc formatting options + /** + * @deprecated Use JavaCodeStyleSettings.ENABLE_JAVADOC_FORMATTING + */ + @Deprecated public boolean ENABLE_JAVADOC_FORMATTING = true; /** - * Align parameter comments to longest parameter name + * Align parameter comments to longest parameter name.JD_ALIGN_PARAM_COMMENTS + * @deprecated Use JavaCodeStyleSettings.JD_ALIGN_PARAM_COMMENTS */ + @Deprecated public boolean JD_ALIGN_PARAM_COMMENTS = true; /** * Align exception comments to longest exception name + * @deprecated Use JavaCodeStyleSettings.JD_ALIGN_EXCEPTION_COMMENTS */ + @Deprecated public boolean JD_ALIGN_EXCEPTION_COMMENTS = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_ADD_BLANK_AFTER_PARM_COMMENTS; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_ADD_BLANK_AFTER_RETURN; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_ADD_BLANK_AFTER_DESCRIPTION = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_P_AT_EMPTY_LINES = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_KEEP_INVALID_TAGS = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_KEEP_EMPTY_LINES = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_DO_NOT_WRAP_ONE_LINE_COMMENTS; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_USE_THROWS_NOT_EXCEPTION = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_KEEP_EMPTY_PARAMETER = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_KEEP_EMPTY_EXCEPTION = true; + /** + * @deprecated Use JavaCodeStyleSettings. + */ + @Deprecated public boolean JD_KEEP_EMPTY_RETURN = true; + /** + * @deprecated Use JavaCodeStyleSettings.JD_LEADING_ASTERISKS_ARE_ENABLED + */ + @Deprecated public boolean JD_LEADING_ASTERISKS_ARE_ENABLED = true; + /** + * @deprecated Use JavaCodeStyleSettings.JD_PRESERVE_LINE_FEEDS + */ + @Deprecated public boolean JD_PRESERVE_LINE_FEEDS; + /** + * @deprecated Use JavaCodeStyleSettings.JD_PARAM_DESCRIPTION_ON_NEW_LINE + */ + @Deprecated public boolean JD_PARAM_DESCRIPTION_ON_NEW_LINE; - + /** + * @deprecated Use JavaCodeStyleSettings.JD_INDENT_ON_CONTINUATION + */ + @Deprecated public boolean JD_INDENT_ON_CONTINUATION = false; // endregion -// region Legacy(!) XML formatting options - - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_KEEP_WHITESPACES; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public int XML_ATTRIBUTE_WRAP = WRAP_AS_NEEDED; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public int XML_TEXT_WRAP = WRAP_AS_NEEDED; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_KEEP_LINE_BREAKS = true; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_KEEP_LINE_BREAKS_IN_TEXT = true; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public int XML_KEEP_BLANK_LINES = 2; - - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_ALIGN_ATTRIBUTES = true; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_ALIGN_TEXT; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_SPACE_AROUND_EQUALITY_IN_ATTRIBUTE; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_SPACE_AFTER_TAG_NAME; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_SPACE_INSIDE_EMPTY_TAG; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public boolean XML_KEEP_WHITE_SPACES_INSIDE_CDATA; - /** - * @deprecated Use XmlCodeStyleSettings. - */ - public int XML_WHITE_SPACE_AROUND_CDATA; - -// endregion - - // region HTML formatting options (legacy) public boolean HTML_KEEP_WHITESPACES; @@ -512,9 +614,7 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea // endregion - // true if <%page import="x.y.z, x.y.t"%> - // false if <%page import="x.y.z"%> - // <%page import="x.y.t"%> + @Deprecated public boolean JSP_PREFER_COMMA_SEPARATED_IMPORT_LIST; //---------------------------------------------------------------------------------------- @@ -580,8 +680,28 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea } } + private static void setVersion(@NotNull Element element, int version) { + element.setAttribute(VERSION_ATTR, Integer.toString(version)); + } + + private static int getVersion(@NotNull Element element) { + String versionStr = element.getAttributeValue(VERSION_ATTR); + if (versionStr == null) { + return 0; + } + else { + try { + return Integer.parseInt(versionStr); + } + catch (NumberFormatException nfe) { + return CURR_VERSION; + } + } + } + @Override public void readExternal(Element element) throws InvalidDataException { + myVersion = getVersion(element); DefaultJDOMExternalizer.readExternal(this, element); if (LAYOUT_STATIC_IMPORTS_SEPARATELY) { // add entry if there is none @@ -639,10 +759,13 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea if (USE_SAME_INDENTS) { IGNORE_SAME_INDENTS_FOR_LANGUAGES = true; } + + migrateLegacySettings(); } @Override public void writeExternal(Element element) throws WriteExternalException { + setVersion(element, myVersion); CodeStyleSettings parentSettings = new CodeStyleSettings(); DefaultJDOMExternalizer.writeExternal(this, element, new DifferenceFilter<>(this, parentSettings)); @@ -854,18 +977,6 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea return getIndentOptions(fileType).USE_TAB_CHARACTER; } - //used in generate equals/hashCode - @SuppressWarnings("unused") - public boolean isGenerateFinalLocals() { - return GENERATE_FINAL_LOCALS; - } - - //used in generate equals/hashCode - @SuppressWarnings("unused") - public boolean isGenerateFinalParameters() { - return GENERATE_FINAL_PARAMETERS; - } - public static class TypeToNameMap implements JDOMExternalizable { private final List myPatterns = new ArrayList<>(); private final List myNames = new ArrayList<>(); @@ -1164,4 +1275,31 @@ public class CodeStyleSettings extends CommonCodeStyleSettings implements Clonea } return myDefaults; } + + private void migrateLegacySettings() { + if (myVersion < CURR_VERSION) { + for (CustomCodeStyleSettings settings : myCustomSettings.values()) { + settings.importLegacySettings(this); + } + myVersion = CURR_VERSION; + } + } + + @SuppressWarnings("deprecation") + public void resetDeprecatedFields() { + CodeStyleSettings defaults = getDefaults(); + ReflectionUtil.copyFields(this.getClass().getFields(), defaults, this, new DifferenceFilter(this, defaults){ + @Override + public boolean isAccept(@NotNull Field field) { + return field.getAnnotation(Deprecated.class) != null; + } + }); + IMPORT_LAYOUT_TABLE.copyFrom(defaults.IMPORT_LAYOUT_TABLE); + PACKAGES_TO_USE_IMPORT_ON_DEMAND.copyFrom(defaults.PACKAGES_TO_USE_IMPORT_ON_DEMAND); + myRepeatAnnotations.clear(); + } + + public int getVersion() { + return myVersion; + } } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettingsManager.java b/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettingsManager.java index be0eb4ca8e6b..4d3d247d6e4f 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettingsManager.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/CodeStyleSettingsManager.java @@ -30,10 +30,19 @@ import org.jdom.Element; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.lang.reflect.Field; + public class CodeStyleSettingsManager implements PersistentStateComponent { private static final Logger LOG = Logger.getInstance(CodeStyleSettingsManager.class); + /** + * Use {@code get/setMainProjectCodeStyle()} instead + * @Deprecated + */ + @SuppressWarnings("DeprecatedIsStillUsed") @Deprecated + @Nullable public volatile CodeStyleSettings PER_PROJECT_SETTINGS; + public volatile boolean USE_PER_PROJECT_SETTINGS; public volatile String PREFERRED_PROJECT_CODE_STYLE; private volatile CodeStyleSettings myTemporarySettings; @@ -41,7 +50,7 @@ public class CodeStyleSettingsManager implements PersistentStateComponent(this, new CodeStyleSettingsManager())); + DefaultJDOMExternalizer.writeExternal(this, result, new DifferenceFilter(this, new CodeStyleSettingsManager()){ + @Override + public boolean isAccept(@NotNull Field field) { + return !isIgnoredOnSave(field.getName()) && super.isAccept(field); + } + }); } catch (WriteExternalException e) { LOG.error(e); @@ -80,6 +94,10 @@ public class CodeStyleSettingsManager implements PersistentStateComponent { private Element myState; diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/ProjectCodeStyleSettingsManager.java b/platform/lang-api/src/com/intellij/psi/codeStyle/ProjectCodeStyleSettingsManager.java index 34ba230efe4d..39ba9326b90f 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/ProjectCodeStyleSettingsManager.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/ProjectCodeStyleSettingsManager.java @@ -16,23 +16,47 @@ package com.intellij.psi.codeStyle; +import com.intellij.openapi.components.MainConfigurationStateSplitter; import com.intellij.openapi.components.ServiceManager; import com.intellij.openapi.components.State; import com.intellij.openapi.components.Storage; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; +import com.intellij.util.containers.ContainerUtil; import org.jdom.Element; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Map; + +import static com.intellij.psi.codeStyle.CodeStyleScheme.CODE_STYLE_NAME_ATTR; +import static com.intellij.psi.codeStyle.CodeStyleScheme.CODE_STYLE_TAG_NAME; -@State(name = "ProjectCodeStyleSettingsManager", storages = @Storage("codeStyleSettings.xml")) -public class ProjectCodeStyleSettingsManager extends CodeStyleSettingsManager{ +@State( + name = "ProjectCodeStyleConfiguration", + storages = @Storage(value = "codeStyles", stateSplitter = ProjectCodeStyleSettingsManager.StateSplitter.class) +) +public class ProjectCodeStyleSettingsManager extends CodeStyleSettingsManager { private static final Logger LOG = Logger.getInstance("#" + ProjectCodeStyleSettingsManager.class); + public static final String MAIN_PROJECT_CODE_STYLE_NAME = "Project"; + public static final String PROJECT_CODE_STYLE_CONFIG_FILE_NAME = "codeStyleConfig"; + private volatile boolean myIsLoaded; private final static Object LEGACY_SETTINGS_IMPORT_LOCK = new Object(); + private final Map mySettingsMap = ContainerUtil.newHashMap(); - void importLegacySettings(@NotNull Project project) { + @SuppressWarnings("unused") + public ProjectCodeStyleSettingsManager(Project project) { + this(); + } + + public ProjectCodeStyleSettingsManager() { + setMainProjectCodeStyle(null); + } + + void initProjectSettings(@NotNull Project project) { if (!myIsLoaded) { synchronized (LEGACY_SETTINGS_IMPORT_LOCK) { if (!myIsLoaded) { @@ -41,14 +65,105 @@ public class ProjectCodeStyleSettingsManager extends CodeStyleSettingsManager{ loadState(legacySettingsManager.getState()); LOG.info("Imported old project code style settings."); } + else { + initDefaults(); + LOG.info("Initialized from default code style settings."); + } } } } } @Override - public void loadState(Element state) { - super.loadState(state); + public void setMainProjectCodeStyle(@Nullable CodeStyleSettings settings) { + // TODO: Remove the assignment below when there are no direct usages of PER_PROJECT_SETTINGS. + //noinspection deprecation + PER_PROJECT_SETTINGS = settings; + mySettingsMap.put(MAIN_PROJECT_CODE_STYLE_NAME, settings != null ? settings : new CodeStyleSettings()); + } + + @NotNull + @Override + public CodeStyleSettings getMainProjectCodeStyle() { + return mySettingsMap.get(MAIN_PROJECT_CODE_STYLE_NAME); + } + + private void initDefaults() { + CodeStyleSettingsManager appCodeStyleSettingsManager = CodeStyleSettingsManager.getInstance(); + if (appCodeStyleSettingsManager != null) { + CodeStyleSettings defaultProjectSettings = appCodeStyleSettingsManager.getMainProjectCodeStyle(); + setMainProjectCodeStyle(defaultProjectSettings != null ? defaultProjectSettings.clone() : null); + this.USE_PER_PROJECT_SETTINGS = appCodeStyleSettingsManager.USE_PER_PROJECT_SETTINGS; + this.PREFERRED_PROJECT_CODE_STYLE = appCodeStyleSettingsManager.PREFERRED_PROJECT_CODE_STYLE; + } myIsLoaded = true; } + + @Override + public void loadState(Element state) { + super.loadState(state); + updateFromOldProjectSettings(); + for (Element subStyle : state.getChildren(CODE_STYLE_TAG_NAME)) { + String name = subStyle.getAttributeValue(CODE_STYLE_NAME_ATTR); + CodeStyleSettings settings = new CodeStyleSettings(); + settings.readExternal(subStyle); + if (MAIN_PROJECT_CODE_STYLE_NAME.equals(name)) { + setMainProjectCodeStyle(settings); + } + else { + mySettingsMap.put(name, settings); + } + } + myIsLoaded = true; + } + + @SuppressWarnings("deprecation") + private void updateFromOldProjectSettings() { + CodeStyleSettings oldProjectSettings = PER_PROJECT_SETTINGS; + if (oldProjectSettings != null) oldProjectSettings.resetDeprecatedFields(); + setMainProjectCodeStyle(oldProjectSettings); + } + + @Override + public Element getState() { + Element e = super.getState(); + if (e != null) { + for (String name : mySettingsMap.keySet()) { + CodeStyleSettings settings = mySettingsMap.get(name); + Element codeStyle = new Element(CODE_STYLE_TAG_NAME); + codeStyle.setAttribute(CODE_STYLE_NAME_ATTR, name); + settings.writeExternal(codeStyle); + if (!codeStyle.getContent().isEmpty()) { + e.addContent(codeStyle); + } + } + } + return e; + } + + @Override + protected boolean isIgnoredOnSave(@NotNull String fieldName) { + return "PER_PROJECT_SETTINGS".equals(fieldName); + } + + public static final class StateSplitter extends MainConfigurationStateSplitter { + + @NotNull + @Override + protected String getComponentStateFileName() { + return PROJECT_CODE_STYLE_CONFIG_FILE_NAME; + } + + @NotNull + @Override + protected String getSubStateTagName() { + return CODE_STYLE_TAG_NAME; + } + + @NotNull + @Override + protected String getSubStateFileName(@NotNull Element element) { + return element.getAttributeValue(CODE_STYLE_NAME_ATTR); + } + } } diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/CodeStyleSchemesModel.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/CodeStyleSchemesModel.java index f386272a881d..10788f118b81 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/CodeStyleSchemesModel.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/CodeStyleSchemesModel.java @@ -151,7 +151,7 @@ public class CodeStyleSchemesModel implements SchemesModel { CodeStyleSettingsManager projectSettingsManager = getProjectSettings(); projectSettingsManager.USE_PER_PROJECT_SETTINGS = isProjectScheme(mySelectedScheme); projectSettingsManager.PREFERRED_PROJECT_CODE_STYLE = mySelectedScheme instanceof ProjectScheme ? null : mySelectedScheme.getName(); - projectSettingsManager.PER_PROJECT_SETTINGS = myProjectScheme.getCodeStyleSettings(); + projectSettingsManager.setMainProjectCodeStyle(myProjectScheme.getCodeStyleSettings()); } private void commitClonedSettings() { @@ -279,7 +279,7 @@ public class CodeStyleSchemesModel implements SchemesModel { private class ProjectScheme extends CodeStyleSchemeImpl { public ProjectScheme() { super(CodeStyleScheme.PROJECT_SCHEME_NAME, false, CodeStyleSchemes.getInstance().getDefaultScheme()); - CodeStyleSettings perProjectSettings = getProjectSettings().PER_PROJECT_SETTINGS; + CodeStyleSettings perProjectSettings = getProjectSettings().getMainProjectCodeStyle(); if (perProjectSettings != null) setCodeStyleSettings(perProjectSettings); } } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/CodeDocumentationUtil.java b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/CodeDocumentationUtil.java index 55fa7ab8db84..2609a2b77c40 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/CodeDocumentationUtil.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/CodeDocumentationUtil.java @@ -22,7 +22,8 @@ import com.intellij.lang.LanguageCommenters; import com.intellij.openapi.editor.Document; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.CodeStyleManager; +import com.intellij.psi.codeStyle.DocCommentSettings; import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.text.CharArrayUtil; import org.jetbrains.annotations.NotNull; @@ -36,8 +37,23 @@ public class CodeDocumentationUtil { private CodeDocumentationUtil() { } + /** + * @deprecated Use createDocCommentLine(lineData,file,commenter) instead. + */ + @SuppressWarnings("unused") + @Deprecated public static String createDocCommentLine(String lineData, Project project, CodeDocumentationAwareCommenter commenter) { - if (!CodeStyleSettingsManager.getSettings(project).JD_LEADING_ASTERISKS_ARE_ENABLED) { + return createLine(lineData, commenter, DocCommentSettings.DEFAULTS); + } + + public static String createDocCommentLine(String lineData, PsiFile file, CodeDocumentationAwareCommenter commenter) { + DocCommentSettings settings = CodeStyleManager.getInstance(file.getProject()).getDocCommentSettings(file); + return createLine(lineData, commenter, settings); + } + + @NotNull + private static String createLine(String lineData, CodeDocumentationAwareCommenter commenter, DocCommentSettings settings) { + if (!settings.isLeadingAsteriskEnabled()) { return " " + lineData + " "; } else { diff --git a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/EnterHandler.java b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/EnterHandler.java index 5eeb995df704..12366a56cff5 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/EnterHandler.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/EnterHandler.java @@ -700,7 +700,7 @@ public class EnterHandler extends BaseEnterHandler { } else { removeTrailingSpaces(myDocument, myOffset); - String toInsert = previousLineIndentUsed ? "*" : CodeDocumentationUtil.createDocCommentLine("", getProject(), commenter); + String toInsert = previousLineIndentUsed ? "*" : CodeDocumentationUtil.createDocCommentLine("", myFile, commenter); myDocument.insertString(myOffset, toInsert); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterAfterJavadocTagHandler.java b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterAfterJavadocTagHandler.java index 1aaaa6b94952..93f77b43d322 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterAfterJavadocTagHandler.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterAfterJavadocTagHandler.java @@ -25,7 +25,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiFile; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.CodeStyleManager; import com.intellij.util.text.CharArrayUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -79,7 +79,9 @@ public class EnterAfterJavadocTagHandler extends EnterHandlerDelegateAdapter { originalHandler.execute(editor, dataContext); Project project = editor.getProject(); - if (indentInsideJavadoc != null && project != null && CodeStyleSettingsManager.getSettings(project).JD_LEADING_ASTERISKS_ARE_ENABLED) { + if (indentInsideJavadoc != null && + project != null && + CodeStyleManager.getInstance(project).getDocCommentSettings(file).isLeadingAsteriskEnabled()) { document.insertString(editor.getCaretModel().getOffset(), "*" + indentInsideJavadoc); } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterBetweenBracesHandler.java b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterBetweenBracesHandler.java index d5b002850086..806f0b2e66cf 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterBetweenBracesHandler.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/EnterBetweenBracesHandler.java @@ -29,7 +29,6 @@ import com.intellij.psi.PsiComment; import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiFile; import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.text.CharArrayUtil; @@ -74,7 +73,9 @@ public class EnterBetweenBracesHandler extends EnterHandlerDelegateAdapter { originalHandler.execute(editor, editor.getCaretModel().getCurrentCaret(), dataContext); Project project = editor.getProject(); - if (indentInsideJavadoc != null && project != null && CodeStyleSettingsManager.getSettings(project).JD_LEADING_ASTERISKS_ARE_ENABLED) { + if (indentInsideJavadoc != null && + project != null && + CodeStyleManager.getInstance(project).getDocCommentSettings(file).isLeadingAsteriskEnabled()) { document.insertString(editor.getCaretModel().getOffset(), "*" + indentInsideJavadoc); } diff --git a/platform/lang-impl/src/com/intellij/ide/actions/QuickChangeCodeStyleSchemeAction.java b/platform/lang-impl/src/com/intellij/ide/actions/QuickChangeCodeStyleSchemeAction.java index f8e9e1792fa0..1803cc1a1725 100644 --- a/platform/lang-impl/src/com/intellij/ide/actions/QuickChangeCodeStyleSchemeAction.java +++ b/platform/lang-impl/src/com/intellij/ide/actions/QuickChangeCodeStyleSchemeAction.java @@ -35,7 +35,7 @@ public class QuickChangeCodeStyleSchemeAction extends QuickSwitchSchemeAction { @Override protected void fillActions(Project project, @NotNull DefaultActionGroup group, @NotNull DataContext dataContext) { final CodeStyleSettingsManager manager = CodeStyleSettingsManager.getInstance(project); - if (manager.PER_PROJECT_SETTINGS != null) { + if (manager.getMainProjectCodeStyle() != null) { //noinspection HardCodedStringLiteral group.add(new AnAction("", "", manager.USE_PER_PROJECT_SETTINGS ? ourCurrentAction : ourNotCurrentAction) { diff --git a/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeStyleSchemeImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeStyleSchemeImpl.java index 1b63b1659db9..08cbb849a985 100644 --- a/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeStyleSchemeImpl.java +++ b/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeStyleSchemeImpl.java @@ -130,8 +130,8 @@ public class CodeStyleSchemeImpl extends ExternalizableSchemeAdapter implements } if (dataHolder == null) { - Element newElement = new Element("code_scheme"); - newElement.setAttribute("name", getName()); + Element newElement = new Element(CODE_STYLE_TAG_NAME); + newElement.setAttribute(CODE_STYLE_NAME_ATTR, getName()); myCodeStyleSettings.writeExternal(newElement); return newElement; } diff --git a/platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateChanged.xml b/platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateChanged.xml new file mode 100644 index 000000000000..e12e81f47a85 --- /dev/null +++ b/platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateChanged.xml @@ -0,0 +1,10 @@ + + + + diff --git a/platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateDefault.xml b/platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateDefault.xml new file mode 100644 index 000000000000..6929827cf0c2 --- /dev/null +++ b/platform/platform-tests/testData/codeStyle/projectSettingsMigration/migrateDefault.xml @@ -0,0 +1,4 @@ + + + diff --git a/platform/platform-tests/testSrc/com/intellij/ide/codeStyleSettings/CodeStyleConfigurationTest.java b/platform/platform-tests/testSrc/com/intellij/ide/codeStyleSettings/CodeStyleConfigurationTest.java index 8a0cdd14c604..153213d7d5a7 100644 --- a/platform/platform-tests/testSrc/com/intellij/ide/codeStyleSettings/CodeStyleConfigurationTest.java +++ b/platform/platform-tests/testSrc/com/intellij/ide/codeStyleSettings/CodeStyleConfigurationTest.java @@ -110,6 +110,7 @@ public class CodeStyleConfigurationTest extends CodeStyleTestCase { settings.OTHER_INDENT_OPTIONS.INDENT_SIZE = 2; Element root = createOption("config", "root"); settings.writeExternal(root); + root.removeAttribute("version"); assertXmlOutputEquals( "

@@ -149,5 +158,16 @@ public class GroovyCodeStyleSettings extends CustomCodeStyleSettings implements public void setLayoutStaticImportsSeparately(boolean value) { LAYOUT_STATIC_IMPORTS_SEPARATELY = value; } - + + @SuppressWarnings("deprecation") + @Override + protected void importLegacySettings(@NotNull CodeStyleSettings rootSettings) { + STATIC_FIELDS_ORDER_WEIGHT = rootSettings.STATIC_FIELDS_ORDER_WEIGHT; + FIELDS_ORDER_WEIGHT = rootSettings.FIELDS_ORDER_WEIGHT; + CONSTRUCTORS_ORDER_WEIGHT = rootSettings.CONSTRUCTORS_ORDER_WEIGHT; + STATIC_METHODS_ORDER_WEIGHT = rootSettings.STATIC_METHODS_ORDER_WEIGHT; + METHODS_ORDER_WEIGHT = rootSettings.METHODS_ORDER_WEIGHT; + STATIC_INNER_CLASSES_ORDER_WEIGHT = rootSettings.STATIC_INNER_CLASSES_ORDER_WEIGHT; + INNER_CLASSES_ORDER_WEIGHT = rootSettings.INNER_CLASSES_ORDER_WEIGHT; + } } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/codeStyle/GroovyCodeStyleSettingsFacadeImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/codeStyle/GroovyCodeStyleSettingsFacadeImpl.java index 5e1520558351..9e4b9fd1effb 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/codeStyle/GroovyCodeStyleSettingsFacadeImpl.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/codeStyle/GroovyCodeStyleSettingsFacadeImpl.java @@ -43,37 +43,37 @@ public class GroovyCodeStyleSettingsFacadeImpl extends GroovyCodeStyleSettingsFa @Override public int staticFieldsOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().STATIC_FIELDS_ORDER_WEIGHT; + return getSettings().STATIC_FIELDS_ORDER_WEIGHT; } @Override public int fieldsOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().FIELDS_ORDER_WEIGHT; + return getSettings().FIELDS_ORDER_WEIGHT; } @Override public int staticMethodsOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().STATIC_METHODS_ORDER_WEIGHT; + return getSettings().STATIC_METHODS_ORDER_WEIGHT; } @Override public int methodsOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().METHODS_ORDER_WEIGHT; + return getSettings().METHODS_ORDER_WEIGHT; } @Override public int staticInnerClassesOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().STATIC_INNER_CLASSES_ORDER_WEIGHT; + return getSettings().STATIC_INNER_CLASSES_ORDER_WEIGHT; } @Override public int innerClassesOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().INNER_CLASSES_ORDER_WEIGHT; + return getSettings().INNER_CLASSES_ORDER_WEIGHT; } @Override public int constructorsOrderWeight() { - return CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings().CONSTRUCTORS_ORDER_WEIGHT; + return getSettings().CONSTRUCTORS_ORDER_WEIGHT; } @Override diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/documentation/GroovyDocumentationProvider.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/documentation/GroovyDocumentationProvider.java index 24a523f72a3f..4db3e67e6539 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/documentation/GroovyDocumentationProvider.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/documentation/GroovyDocumentationProvider.java @@ -500,13 +500,13 @@ public class GroovyDocumentationProvider implements CodeDocumentationProvider, E final PsiType returnType = method.getInferredReturnType(); if ((returnType != null || method.getModifierList().hasModifierProperty(GrModifier.DEF)) && !PsiType.VOID.equals(returnType)) { - builder.append(CodeDocumentationUtil.createDocCommentLine(RETURN_TAG, project, commenter)); + builder.append(CodeDocumentationUtil.createDocCommentLine(RETURN_TAG, contextComment.getContainingFile(), commenter)); builder.append(LINE_SEPARATOR); } final PsiClassType[] references = method.getThrowsList().getReferencedTypes(); for (PsiClassType reference : references) { - builder.append(CodeDocumentationUtil.createDocCommentLine(THROWS_TAG, project, commenter)); + builder.append(CodeDocumentationUtil.createDocCommentLine(THROWS_TAG, contextComment.getContainingFile(), commenter)); builder.append(reference.getClassName()); builder.append(LINE_SEPARATOR); } diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXQuickfixTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXQuickfixTest.java index 196753d84891..99ad1d041a4d 100644 --- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXQuickfixTest.java +++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXQuickfixTest.java @@ -22,8 +22,8 @@ import com.intellij.openapi.module.Module; import com.intellij.openapi.roots.ContentEntry; import com.intellij.openapi.roots.ModifiableRootModel; import com.intellij.psi.PsiModifier; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.xml.XmlFile; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.PlatformTestUtil; @@ -141,7 +141,7 @@ public class JavaFXQuickfixTest extends LightCodeInsightFixtureTestCase { final String inputName, final String defaultVisibility, final String extension) throws Exception { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); String savedVisibility = settings.VISIBILITY; try { settings.VISIBILITY = defaultVisibility; diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXUnresolvedFxIdReferenceInspectionTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXUnresolvedFxIdReferenceInspectionTest.java index 1427706ff56e..f5efd5700e69 100644 --- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXUnresolvedFxIdReferenceInspectionTest.java +++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXUnresolvedFxIdReferenceInspectionTest.java @@ -17,8 +17,8 @@ package org.jetbrains.plugins.javaFX.fxml; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.application.PluginPathManager; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.util.VisibilityUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.plugins.javaFX.fxml.codeInsight.inspections.JavaFxUnresolvedFxIdReferenceInspection; @@ -61,7 +61,7 @@ public class JavaFXUnresolvedFxIdReferenceInspectionTest extends AbstractJavaFXQ } private void doTest(final String controllerName, final String defaultVisibility) { - CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); String savedVisibility = settings.VISIBILITY; try { settings.VISIBILITY = defaultVisibility; diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFxEventHandlerInspectionTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFxEventHandlerInspectionTest.java index 888e5d2f3cdb..25c1cf48a092 100644 --- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFxEventHandlerInspectionTest.java +++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFxEventHandlerInspectionTest.java @@ -2,8 +2,8 @@ package org.jetbrains.plugins.javaFX.fxml; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.application.PluginPathManager; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import org.jetbrains.annotations.NotNull; import org.jetbrains.plugins.javaFX.fxml.codeInsight.inspections.JavaFxEventHandlerInspection; @@ -78,7 +78,7 @@ public class JavaFxEventHandlerInspectionTest extends AbstractJavaFXTestCase { } public void testQuickfixNoFieldNested() throws Exception { - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(JavaCodeStyleSettings.class); final boolean oldImports = settings.INSERT_INNER_CLASS_IMPORTS; try { settings.INSERT_INNER_CLASS_IMPORTS = true; diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java index 0a94607b70ef..6dbcf8bab838 100644 --- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java +++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java @@ -26,8 +26,8 @@ import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.impl.source.codeStyle.ImportHelper; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.xml.*; @@ -65,7 +65,7 @@ public class JavaFxImportsOptimizer implements ImportOptimizer { final Set demandedForNested = new HashSet<>(); collectNamesToImport(names, demandedForNested, (XmlFile)file); Collections.sort(names, (o1, o2) -> StringUtil.compare(o1.first, o2.first, true)); - final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project); + final JavaCodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project).getCustomSettings(JavaCodeStyleSettings.class); final List> sortedNames = ImportHelper.sortItemsAccordingToSettings(names, settings); final Map onDemand = new HashMap<>(); ImportHelper.collectOnDemandImports(sortedNames, settings, onDemand); diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxUnresolvedFxIdReferenceInspection.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxUnresolvedFxIdReferenceInspection.java index 5668943ec284..81d430603207 100644 --- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxUnresolvedFxIdReferenceInspection.java +++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxUnresolvedFxIdReferenceInspection.java @@ -28,6 +28,7 @@ import com.intellij.lang.refactoring.NamesValidator; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.xml.XmlAttribute; import com.intellij.psi.xml.XmlAttributeValue; @@ -144,7 +145,8 @@ public class JavaFxUnresolvedFxIdReferenceInspection extends XmlSuppressableInsp final PsiModifierList modifierList = field.getModifierList(); if (modifierList != null) { @PsiModifier.ModifierConstant - String visibility = CodeStyleSettingsManager.getSettings(targetClass.getProject()).VISIBILITY; + String visibility = + CodeStyleSettingsManager.getSettings(targetClass.getProject()).getCustomSettings(JavaCodeStyleSettings.class).VISIBILITY; if (VisibilityUtil.ESCALATE_VISIBILITY.equals(visibility)) visibility = PsiModifier.PRIVATE; VisibilityUtil.setVisibility(modifierList, visibility); if (!PsiModifier.PUBLIC.equals(visibility)) { diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java index 96245645d04a..a53228676c31 100644 --- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java +++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java @@ -22,10 +22,7 @@ import com.intellij.lang.jvm.actions.MemberRequest; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.TextRange; import com.intellij.psi.*; -import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; -import com.intellij.psi.codeStyle.SuggestedNameInfo; -import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.codeStyle.*; import com.intellij.psi.util.InheritanceUtil; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.psi.xml.XmlAttribute; @@ -153,7 +150,7 @@ public class JavaFxEventHandlerReference extends PsiReferenceBase(result); - Collections.sort((List)result, CodeStyleSettingsManager.getSettings(myProject).PREFER_LONGER_NAMES ? - StringLenComparator.getDescendingInstance() : StringLenComparator.getInstance()); + Collections.sort((List)result, + CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JavaCodeStyleSettings.class).PREFER_LONGER_NAMES ? + StringLenComparator.getDescendingInstance() : StringLenComparator.getInstance()); return ArrayUtil.toStringArray(result); } diff --git a/xml/impl/src/com/intellij/psi/formatter/xml/XmlCodeStyleSettings.java b/xml/impl/src/com/intellij/psi/formatter/xml/XmlCodeStyleSettings.java index aa52d88f058d..1c4a76ab036a 100644 --- a/xml/impl/src/com/intellij/psi/formatter/xml/XmlCodeStyleSettings.java +++ b/xml/impl/src/com/intellij/psi/formatter/xml/XmlCodeStyleSettings.java @@ -53,40 +53,4 @@ public class XmlCodeStyleSettings extends CustomCodeStyleSettings { super("XML", container); } - @Override - protected void importLegacySettings() { - if (!XML_LEGACY_SETTINGS_IMPORTED) { - CodeStyleSettings container = getContainer(); - CodeStyleSettings defaults = new CodeStyleSettings(); - XML_KEEP_WHITESPACES = container.XML_KEEP_WHITESPACES; - XML_ATTRIBUTE_WRAP = container.XML_ATTRIBUTE_WRAP; - XML_TEXT_WRAP = container.XML_TEXT_WRAP; - XML_KEEP_LINE_BREAKS = container.XML_KEEP_LINE_BREAKS; - XML_KEEP_LINE_BREAKS_IN_TEXT = container.XML_KEEP_LINE_BREAKS_IN_TEXT; - XML_KEEP_BLANK_LINES = container.XML_KEEP_BLANK_LINES; - XML_ALIGN_ATTRIBUTES = container.XML_ALIGN_ATTRIBUTES; - XML_ALIGN_TEXT = container.XML_ALIGN_TEXT; - XML_SPACE_AROUND_EQUALITY_IN_ATTRIBUTE = container.XML_SPACE_AROUND_EQUALITY_IN_ATTRIBUTE; - XML_SPACE_AFTER_TAG_NAME = container.XML_SPACE_AFTER_TAG_NAME; - XML_SPACE_INSIDE_EMPTY_TAG = container.XML_SPACE_INSIDE_EMPTY_TAG; - XML_KEEP_WHITE_SPACES_INSIDE_CDATA = container.XML_KEEP_WHITE_SPACES_INSIDE_CDATA; - XML_WHITE_SPACE_AROUND_CDATA = container.XML_WHITE_SPACE_AROUND_CDATA; - - container.XML_KEEP_WHITESPACES = defaults.XML_KEEP_WHITESPACES ; - container.XML_ATTRIBUTE_WRAP = defaults.XML_ATTRIBUTE_WRAP; - container.XML_TEXT_WRAP = defaults.XML_TEXT_WRAP; - container.XML_KEEP_LINE_BREAKS = defaults.XML_KEEP_LINE_BREAKS; - container.XML_KEEP_LINE_BREAKS_IN_TEXT = defaults.XML_KEEP_LINE_BREAKS_IN_TEXT; - container.XML_KEEP_BLANK_LINES = defaults.XML_KEEP_BLANK_LINES; - container.XML_ALIGN_ATTRIBUTES = defaults.XML_ALIGN_ATTRIBUTES; - container.XML_ALIGN_TEXT = defaults.XML_ALIGN_TEXT; - container.XML_SPACE_AROUND_EQUALITY_IN_ATTRIBUTE = defaults.XML_SPACE_AROUND_EQUALITY_IN_ATTRIBUTE; - container.XML_SPACE_AFTER_TAG_NAME = defaults.XML_SPACE_AFTER_TAG_NAME; - container.XML_SPACE_INSIDE_EMPTY_TAG = defaults.XML_SPACE_INSIDE_EMPTY_TAG; - container.XML_KEEP_WHITE_SPACES_INSIDE_CDATA = defaults.XML_KEEP_WHITE_SPACES_INSIDE_CDATA; - container.XML_WHITE_SPACE_AROUND_CDATA = defaults.XML_WHITE_SPACE_AROUND_CDATA; - - XML_LEGACY_SETTINGS_IMPORTED = true; - } - } }