From 76ebb5a63bc67db494ce789d625dcd6cd17547cb Mon Sep 17 00:00:00 2001 From: Rustam Vishnyakov Date: Wed, 6 Feb 2019 14:10:54 +0300 Subject: [PATCH] Extract generic code style property accessor not limited with fields with example implementation for Java repeat_annotations property --- ...JavaLanguageCodeStyleSettingsProvider.java | 44 +++++++++- .../testData/codeStyle/jsonExport.j2ee.json | 4 + .../testData/codeStyle/jsonExport.json | 4 + .../codeStyle/JavaCodeStyleSettingsTest.java | 6 ++ .../AbstractCodeStylePropertyMapper.java | 19 ++--- .../codeStyle/properties/BooleanAccessor.java | 2 +- .../properties/CodeStyleFieldAccessor.java | 81 +++++++++++++++++++ .../properties/CodeStylePropertyAccessor.java | 74 ++--------------- .../CommaSeparatedValuesAccessor.java | 1 - .../properties/ExternalStringAccessor.java | 2 +- ...Factory.java => FieldAccessorFactory.java} | 8 +- .../codeStyle/properties/IntegerAccessor.java | 2 +- .../LanguageCodeStylePropertyMapper.java | 15 +++- .../properties/ValueListPropertyAccessor.java | 4 +- .../properties/WrapOnTypingAccessor.java | 2 +- .../LanguageCodeStyleSettingsProvider.java | 12 +-- .../json/CodeStyleSchemeJsonExporter.java | 9 ++- 17 files changed, 186 insertions(+), 103 deletions(-) create mode 100644 platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStyleFieldAccessor.java rename platform/lang-api/src/com/intellij/application/options/codeStyle/properties/{PropertyAccessorFactory.java => FieldAccessorFactory.java} (94%) diff --git a/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java b/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java index 6bc7538c1818..a7f251fa3ee6 100644 --- a/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java +++ b/java/java-impl/src/com/intellij/ide/JavaLanguageCodeStyleSettingsProvider.java @@ -16,7 +16,9 @@ package com.intellij.ide; import com.intellij.application.options.*; +import com.intellij.application.options.codeStyle.properties.CodeStyleFieldAccessor; import com.intellij.application.options.codeStyle.properties.CodeStylePropertyAccessor; +import com.intellij.application.options.codeStyle.properties.ValueListPropertyAccessor; import com.intellij.lang.Language; import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.application.ApplicationBundle; @@ -32,6 +34,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; +import java.util.Collections; +import java.util.List; import static com.intellij.application.options.JavaDocFormattingPanel.*; @@ -331,13 +335,51 @@ public class JavaLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSett @Nullable @Override - public CodeStylePropertyAccessor getAccessor(@NotNull Object codeStyleObject, @NotNull Field field) { + public CodeStyleFieldAccessor getAccessor(@NotNull Object codeStyleObject, @NotNull Field field) { if (PackageEntryTable.class.isAssignableFrom(field.getType())) { return new JavaPackageEntryTableAccessor(codeStyleObject, field); } return super.getAccessor(codeStyleObject, field); } + @Override + public List getAdditionalAccessors(@NotNull Object codeStyleObject) { + if (codeStyleObject instanceof JavaCodeStyleSettings) { + return Collections.singletonList(new RepeatAnnotationsAccessor((JavaCodeStyleSettings)codeStyleObject)); + } + return super.getAdditionalAccessors(codeStyleObject); + } + + private static class RepeatAnnotationsAccessor extends CodeStylePropertyAccessor> { + + private final JavaCodeStyleSettings mySettings; + + RepeatAnnotationsAccessor(@NotNull JavaCodeStyleSettings settings) { + mySettings = settings; + } + + @Override + public boolean set(@NotNull List extVal) { + mySettings.setRepeatAnnotations(extVal); + return true; + } + + @Override + public List get() { + return mySettings.getRepeatAnnotations(); + } + + @Override + protected List parseString(@NotNull String string) { + return ValueListPropertyAccessor.getValueList(string); + } + + @Override + public String getPropertyName() { + return "repeat_annotations"; + } + } + private static final String GENERAL_CODE_SAMPLE = "public class Foo {\n" + " public int[] X = new int[]{1, 3, 5, 7, 9, 11};\n" + diff --git a/java/java-tests/testData/codeStyle/jsonExport.j2ee.json b/java/java-tests/testData/codeStyle/jsonExport.j2ee.json index 57e0a2e9a93d..5c3cf874f04a 100644 --- a/java/java-tests/testData/codeStyle/jsonExport.j2ee.json +++ b/java/java-tests/testData/codeStyle/jsonExport.j2ee.json @@ -150,6 +150,10 @@ "place_assignment_sign_on_next_line": false, "prefer_longer_names": true, "prefer_parameters_wrap": false, + "repeat_annotations": [ + "com.jetbrains.First", + "com.jetbrains.Second" + ], "repeat_synchronized": true, "replace_instanceof_and_cast": false, "replace_null_check": true, diff --git a/java/java-tests/testData/codeStyle/jsonExport.json b/java/java-tests/testData/codeStyle/jsonExport.json index 7fceabe54131..95d4da6b067c 100644 --- a/java/java-tests/testData/codeStyle/jsonExport.json +++ b/java/java-tests/testData/codeStyle/jsonExport.json @@ -140,6 +140,10 @@ "place_assignment_sign_on_next_line": false, "prefer_longer_names": true, "prefer_parameters_wrap": false, + "repeat_annotations": [ + "com.jetbrains.First", + "com.jetbrains.Second" + ], "repeat_synchronized": true, "replace_instanceof_and_cast": false, "replace_null_check": true, diff --git a/java/java-tests/testSrc/com/intellij/java/psi/codeStyle/JavaCodeStyleSettingsTest.java b/java/java-tests/testSrc/com/intellij/java/psi/codeStyle/JavaCodeStyleSettingsTest.java index 23708f946d7f..ea44ab49f40c 100644 --- a/java/java-tests/testSrc/com/intellij/java/psi/codeStyle/JavaCodeStyleSettingsTest.java +++ b/java/java-tests/testSrc/com/intellij/java/psi/codeStyle/JavaCodeStyleSettingsTest.java @@ -86,6 +86,7 @@ public class JavaCodeStyleSettingsTest extends CodeStyleTestCase { final JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); javaSettings.FIELD_NAME_PREFIX = "m_"; javaSettings.STATIC_FIELD_NAME_SUFFIX = "_s"; + javaSettings.setRepeatAnnotations(Arrays.asList("com.jetbrains.First", "com.jetbrains.Second")); CodeStyleSchemeJsonExporter exporter = new CodeStyleSchemeJsonExporter(); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); @@ -114,6 +115,7 @@ public class JavaCodeStyleSettingsTest extends CodeStyleTestCase { setSimple(mapper, "doc_align_param_comments", "true"); setList(mapper, "imports_layout", Arrays.asList("com.jetbrains.*", "blank_line", "org.eclipse.bar", "static **", "static org.eclipse.foo.**")); + mapper.getAccessor("repeat_annotations").setFromString(" com.jetbrains.First, com.jetbrains.Second"); final CommonCodeStyleSettings commonJavaSettings = settings.getCommonSettings(JavaLanguage.INSTANCE); final JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); assertTrue(commonJavaSettings.ALIGN_GROUP_FIELD_DECLARATIONS); @@ -127,6 +129,10 @@ public class JavaCodeStyleSettingsTest extends CodeStyleTestCase { assertEquals(new PackageEntry(false, "org.eclipse.bar", false), importsTable.getEntryAt(2)); assertEquals(PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY, importsTable.getEntryAt(3)); assertEquals(new PackageEntry(true, "org.eclipse.foo", true), importsTable.getEntryAt(4)); + List repeatAnno = javaSettings.getRepeatAnnotations(); + assertEquals(2, repeatAnno.size()); + assertEquals("com.jetbrains.First", repeatAnno.get(0)); + assertEquals("com.jetbrains.Second", repeatAnno.get(1)); } private static void setSimple(@NotNull AbstractCodeStylePropertyMapper mapper, @NotNull String name, @NotNull String value) { diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/AbstractCodeStylePropertyMapper.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/AbstractCodeStylePropertyMapper.java index ee6a200e435e..ad3a109a9099 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/AbstractCodeStylePropertyMapper.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/AbstractCodeStylePropertyMapper.java @@ -28,30 +28,21 @@ public abstract class AbstractCodeStylePropertyMapper { return getAccessorMap().keySet().stream().sorted().collect(Collectors.toList()); } - public List enumPropertiesFor(@NotNull Class... codeStyleClass) { - final Map accessorMap = myAccessorMap.getValue(); - return accessorMap.keySet().stream().filter(name -> { - CodeStylePropertyAccessor accessor = accessorMap.get(name); - for (Class aClass : codeStyleClass) { - if (accessor.getObjectClass().equals(aClass)) { - return true; - } - } - return false; - }).sorted().collect(Collectors.toList()); - } - private Map createMap() { Map accessorMap = ContainerUtil.newHashMap(); for (CodeStyleObjectDescriptor descriptor : getSupportedFields()) { addAccessorsFor(accessorMap, descriptor.getCodeStyleObject(), descriptor.getSupportedFields()); } + addAdditionalAccessors(accessorMap); return accessorMap; } @NotNull protected abstract List getSupportedFields(); + protected void addAdditionalAccessors(@NotNull Map accessorMap) { + } + private void addAccessorsFor(@NotNull Map accessorMap, @NotNull Object codeStyleObject, @Nullable Set supportedFields) { @@ -69,7 +60,7 @@ public abstract class AbstractCodeStylePropertyMapper { @Nullable protected CodeStylePropertyAccessor getAccessor(@NotNull Object codeStyleObject, @NotNull Field field) { - return new PropertyAccessorFactory(field).createAccessor(codeStyleObject); + return new FieldAccessorFactory(field).createAccessor(codeStyleObject); } private List getCodeStyleFields(Class codeStyleClass) { diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/BooleanAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/BooleanAccessor.java index dc8355565a6d..95414bb25adb 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/BooleanAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/BooleanAccessor.java @@ -8,7 +8,7 @@ import java.lang.reflect.Field; import java.util.Arrays; import java.util.List; -public class BooleanAccessor extends CodeStylePropertyAccessor implements CodeStyleChoiceList { +public class BooleanAccessor extends CodeStyleFieldAccessor implements CodeStyleChoiceList { private final static List BOOLEAN_VALS = Arrays.asList("false", "true"); diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStyleFieldAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStyleFieldAccessor.java new file mode 100644 index 000000000000..0bd698d4ff46 --- /dev/null +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStyleFieldAccessor.java @@ -0,0 +1,81 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.application.options.codeStyle.properties; + +import com.intellij.configurationStore.Property; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.codeStyle.CommonCodeStyleSettings; +import org.jetbrains.annotations.ApiStatus; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.lang.reflect.Field; + +@ApiStatus.Experimental +public abstract class CodeStyleFieldAccessor extends CodeStylePropertyAccessor { + private final Object myObject; + private final Field myField; + + public CodeStyleFieldAccessor(@NotNull Object object, @NotNull Field field) { + myObject = object; + myField = field; + } + + @Override + public boolean set(@NotNull V extVal) { + try { + T value = fromExternal(extVal); + if (value != null) { + myField.set(myObject, value); + return true; + } + } + catch (IllegalAccessException e) { + // Ignore and skip + } + return false; + } + + @Override + @Nullable + public V get() { + try { + //noinspection unchecked + T value = (T)myField.get(myObject); + return value != null && !isEmpty(value) ? toExternal(value) : null; + } + catch (IllegalAccessException e) { + // Ignore and return null + } + return null; + } + + @NotNull + public Class getObjectClass() { + return myObject.getClass(); + } + + protected boolean isEmpty(@NotNull T value) { + return false; + } + + @Nullable + protected abstract T fromExternal(@NotNull V extVal); + + @NotNull + protected abstract V toExternal(@NotNull T value); + + @Override + public String getPropertyName() { + Property descriptor = myField.getAnnotation(Property.class); + if (descriptor != null) { + String externalName = descriptor.externalName(); + if (!StringUtil.isEmpty(externalName)) return externalName; + } + return PropertyNameUtil.getPropertyName(myField.getName()); + } + + @Override + public boolean isGenericProperty() { + return myObject instanceof CommonCodeStyleSettings || myObject instanceof CommonCodeStyleSettings.IndentOptions; + } +} diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStylePropertyAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStylePropertyAccessor.java index 4a022f65be4b..6bcd26616311 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStylePropertyAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CodeStylePropertyAccessor.java @@ -1,51 +1,12 @@ -// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package com.intellij.application.options.codeStyle.properties; -import com.intellij.configurationStore.Property; -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.codeStyle.CommonCodeStyleSettings; -import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import java.lang.reflect.Field; +public abstract class CodeStylePropertyAccessor { + public abstract boolean set(@NotNull V extVal); -@ApiStatus.Experimental -public abstract class CodeStylePropertyAccessor { - private final Object myObject; - private final Field myField; - - public CodeStylePropertyAccessor(@NotNull Object object, @NotNull Field field) { - myObject = object; - myField = field; - } - - public boolean set(@NotNull V extVal) { - try { - T value = fromExternal(extVal); - if (value != null) { - myField.set(myObject, value); - return true; - } - } - catch (IllegalAccessException e) { - // Ignore and skip - } - return false; - } - - @Nullable - public V get() { - try { - //noinspection unchecked - T value = (T)myField.get(myObject); - return value != null && !isEmpty(value) ? toExternal(value) : null; - } - catch (IllegalAccessException e) { - // Ignore and return null - } - return null; - } + public abstract V get(); public final boolean setFromString(@NotNull String valueString) { V extValue = parseString(valueString); @@ -55,34 +16,11 @@ public abstract class CodeStylePropertyAccessor { return false; } - @Nullable protected abstract V parseString(@NotNull String string); - @NotNull - public Class getObjectClass() { - return myObject.getClass(); - } - - protected boolean isEmpty(@NotNull T value) { + public boolean isGenericProperty() { return false; } - @Nullable - protected abstract T fromExternal(@NotNull V extVal); - - @NotNull - protected abstract V toExternal(@NotNull T value); - - public String getPropertyName() { - Property descriptor = myField.getAnnotation(Property.class); - if (descriptor != null) { - String externalName = descriptor.externalName(); - if (!StringUtil.isEmpty(externalName)) return externalName; - } - return PropertyNameUtil.getPropertyName(myField.getName()); - } - - public boolean isGenericProperty() { - return myObject instanceof CommonCodeStyleSettings || myObject instanceof CommonCodeStyleSettings.IndentOptions; - } + public abstract String getPropertyName(); } diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CommaSeparatedValuesAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CommaSeparatedValuesAccessor.java index e3163c386ee2..e7af3682cd85 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CommaSeparatedValuesAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/CommaSeparatedValuesAccessor.java @@ -1,7 +1,6 @@ // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package com.intellij.application.options.codeStyle.properties; -import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ExternalStringAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ExternalStringAccessor.java index 8dc8c0975c3a..aa0b222545d1 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ExternalStringAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ExternalStringAccessor.java @@ -6,7 +6,7 @@ import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; -public abstract class ExternalStringAccessor extends CodeStylePropertyAccessor { +public abstract class ExternalStringAccessor extends CodeStyleFieldAccessor { public ExternalStringAccessor(@NotNull Object object, @NotNull Field field) { super(object, field); diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/PropertyAccessorFactory.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/FieldAccessorFactory.java similarity index 94% rename from platform/lang-api/src/com/intellij/application/options/codeStyle/properties/PropertyAccessorFactory.java rename to platform/lang-api/src/com/intellij/application/options/codeStyle/properties/FieldAccessorFactory.java index 38d9b6cc8df5..c99da4966be4 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/PropertyAccessorFactory.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/FieldAccessorFactory.java @@ -6,11 +6,11 @@ import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; -class PropertyAccessorFactory { +class FieldAccessorFactory { private final Field myField; - PropertyAccessorFactory(Field field) { + FieldAccessorFactory(Field field) { myField = field; } @@ -56,7 +56,7 @@ class PropertyAccessorFactory { } @Nullable - CodeStylePropertyAccessor createAccessor(@NotNull Object codeStyleObject) { + CodeStyleFieldAccessor createAccessor(@NotNull Object codeStyleObject) { if (mayHaveAccessor()) { switch (getValueType()) { case BOOLEAN: @@ -95,7 +95,7 @@ class PropertyAccessorFactory { myField.getAnnotation(Deprecated.class) == null; } - private static class TabCharPropertyAccessor extends CodeStylePropertyAccessor { + private static class TabCharPropertyAccessor extends CodeStyleFieldAccessor { TabCharPropertyAccessor(@NotNull Object object, @NotNull Field field) { super(object, field); diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/IntegerAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/IntegerAccessor.java index e7175a64be29..2384b22e51f8 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/IntegerAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/IntegerAccessor.java @@ -6,7 +6,7 @@ import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; -public class IntegerAccessor extends CodeStylePropertyAccessor { +public class IntegerAccessor extends CodeStyleFieldAccessor { IntegerAccessor(@NotNull Object object, @NotNull Field field) { super(object, field); } diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/LanguageCodeStylePropertyMapper.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/LanguageCodeStylePropertyMapper.java index 22e43e4d714c..be4ad37f1568 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/LanguageCodeStylePropertyMapper.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/LanguageCodeStylePropertyMapper.java @@ -22,6 +22,7 @@ public final class LanguageCodeStylePropertyMapper extends AbstractCodeStyleProp private @NotNull final Language myLanguage; private @NotNull final String myLanguageDomainId; private @Nullable final LanguageCodeStyleSettingsProvider mySettingsProvider; + private @NotNull final List myCustomSettings; public LanguageCodeStylePropertyMapper(@NotNull CodeStyleSettings settings, @NotNull Language language, @@ -30,6 +31,7 @@ public final class LanguageCodeStylePropertyMapper extends AbstractCodeStyleProp myLanguage = language; myLanguageDomainId = languageDomainId == null ? myLanguage.getID().toLowerCase(Locale.ENGLISH) : languageDomainId; mySettingsProvider = LanguageCodeStyleSettingsProvider.forLanguage(language); + myCustomSettings = getCustomSettings(); } @Nullable @@ -42,6 +44,17 @@ public final class LanguageCodeStylePropertyMapper extends AbstractCodeStyleProp return super.getAccessor(codeStyleObject, field); } + @Override + protected void addAdditionalAccessors(@NotNull Map accessorMap) { + if (mySettingsProvider != null) { + for (CustomCodeStyleSettings customSettings : myCustomSettings) { + for (CodeStylePropertyAccessor accessor : mySettingsProvider.getAdditionalAccessors(customSettings)) { + accessorMap.put(accessor.getPropertyName(), accessor); + } + } + } + } + @NotNull @Override protected List getSupportedFields() { @@ -51,7 +64,7 @@ public final class LanguageCodeStylePropertyMapper extends AbstractCodeStyleProp fieldsDescriptors.add(new CodeStyleObjectDescriptor(indentOptions, getSupportedIndentOptions())); } fieldsDescriptors.add(new CodeStyleObjectDescriptor(getRootSettings().getCommonSettings(myLanguage), getSupportedLanguageFields())); - for (CustomCodeStyleSettings customSettings : getCustomSettings()) { + for (CustomCodeStyleSettings customSettings : myCustomSettings) { fieldsDescriptors.add(new CodeStyleObjectDescriptor(customSettings, null)); } return fieldsDescriptors; diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ValueListPropertyAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ValueListPropertyAccessor.java index 4d453f5180eb..562082636506 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ValueListPropertyAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/ValueListPropertyAccessor.java @@ -8,7 +8,7 @@ import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; import java.util.List; -public abstract class ValueListPropertyAccessor extends CodeStylePropertyAccessor> { +public abstract class ValueListPropertyAccessor extends CodeStyleFieldAccessor> { public ValueListPropertyAccessor(@NotNull Object object, @NotNull Field field) { super(object, field); } @@ -28,7 +28,7 @@ public abstract class ValueListPropertyAccessor extends CodeStylePropertyAcce } @NotNull - protected static List getValueList(@NotNull String string) { + public static List getValueList(@NotNull String string) { return ContainerUtil.map(string.split(","), s -> s.trim()); } } diff --git a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/WrapOnTypingAccessor.java b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/WrapOnTypingAccessor.java index 3cd598409321..4ab8bf625548 100644 --- a/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/WrapOnTypingAccessor.java +++ b/platform/lang-api/src/com/intellij/application/options/codeStyle/properties/WrapOnTypingAccessor.java @@ -7,7 +7,7 @@ import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; -public class WrapOnTypingAccessor extends CodeStylePropertyAccessor { +public class WrapOnTypingAccessor extends CodeStyleFieldAccessor { WrapOnTypingAccessor(@NotNull Object object, @NotNull Field field) { super(object, field); } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/LanguageCodeStyleSettingsProvider.java b/platform/lang-api/src/com/intellij/psi/codeStyle/LanguageCodeStyleSettingsProvider.java index 3733ec9a0b9f..4eacb88b1830 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/LanguageCodeStyleSettingsProvider.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/LanguageCodeStyleSettingsProvider.java @@ -3,6 +3,7 @@ package com.intellij.psi.codeStyle; import com.intellij.application.options.IndentOptionsEditor; import com.intellij.application.options.codeStyle.properties.AbstractCodeStylePropertyMapper; +import com.intellij.application.options.codeStyle.properties.CodeStyleFieldAccessor; import com.intellij.application.options.codeStyle.properties.CodeStylePropertyAccessor; import com.intellij.application.options.codeStyle.properties.LanguageCodeStylePropertyMapper; import com.intellij.lang.IdeLanguageCustomization; @@ -18,10 +19,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.List; -import java.util.Locale; -import java.util.Set; +import java.util.*; import java.util.concurrent.atomic.AtomicReference; /** @@ -377,7 +375,11 @@ public abstract class LanguageCodeStyleSettingsProvider extends CodeStyleSetting @ApiStatus.Experimental @Nullable - public CodeStylePropertyAccessor getAccessor(@NotNull Object codeStyleObject, @NotNull Field field) { + public CodeStyleFieldAccessor getAccessor(@NotNull Object codeStyleObject, @NotNull Field field) { return null; } + + public List getAdditionalAccessors(@NotNull Object codeStyleObject) { + return Collections.emptyList(); + } } diff --git a/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/json/CodeStyleSchemeJsonExporter.java b/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/json/CodeStyleSchemeJsonExporter.java index 31a92d69596c..e3e7bf08844a 100644 --- a/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/json/CodeStyleSchemeJsonExporter.java +++ b/platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/json/CodeStyleSchemeJsonExporter.java @@ -67,10 +67,13 @@ public class CodeStyleSchemeJsonExporter extends SchemeExporter else if (externalized instanceof Boolean) { o.addProperty(name, (Boolean)externalized); } - else if (externalized != null && accessor instanceof ValueListPropertyAccessor) { - @SuppressWarnings("unchecked") List listValues = (List)externalized; + else if (externalized instanceof List) { final JsonArray array = new JsonArray(); - listValues.forEach(s -> array.add(s)); + for (Object element : (List)externalized) { + if (element instanceof String) { + array.add((String)element); + } + } o.add(name, array); } }