diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java index 368679aa2bfc..ebf9a736a8b5 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/AbstractFileType.java @@ -304,11 +304,7 @@ public class AbstractFileType extends UserFileType implements @NonNls static final String ELEMENT_MAPPING = "mapping"; @NonNls static final String ATTRIBUTE_EXT = "ext"; - @NonNls private static final String ATTRIBUTE_PATTERN = "pattern"; - /** Applied for removed mappings approved by user */ - @NonNls private static final String ATTRIBUTE_APPROVED = "approved"; - - @NonNls private static final String ELEMENT_REMOVED_MAPPING = "removed_mapping"; + @NonNls static final String ATTRIBUTE_PATTERN = "pattern"; @NonNls static final String ATTRIBUTE_TYPE = "type"; @NotNull @@ -329,22 +325,6 @@ public class AbstractFileType extends UserFileType implements return result; } - @NotNull - public static List> readRemovedAssociations(@NotNull Element element) { - List children = element.getChildren(ELEMENT_REMOVED_MAPPING); - if (children.isEmpty()) { - return Collections.emptyList(); - } - - List> result = new SmartList<>(); - for (Element mapping : children) { - String ext = mapping.getAttributeValue(ATTRIBUTE_EXT); - FileNameMatcher matcher = ext == null ? FileTypeManager.parseFromString(mapping.getAttributeValue(ATTRIBUTE_PATTERN)) : new ExtensionFileNameMatcher(ext); - result.add(Trinity.create(matcher, mapping.getAttributeValue(ATTRIBUTE_TYPE), Boolean.parseBoolean(mapping.getAttributeValue(ATTRIBUTE_APPROVED)))); - } - return result; - } - @Nullable public static Element writeMapping(String typeName, @NotNull FileNameMatcher matcher, boolean specifyTypeName) { Element mapping = new Element(ELEMENT_MAPPING); @@ -362,25 +342,7 @@ public class AbstractFileType extends UserFileType implements return mapping; } - static Element writeRemovedMapping(@NotNull FileType type, @NotNull FileNameMatcher matcher, boolean specifyTypeName, boolean approved) { - Element mapping = new Element(ELEMENT_REMOVED_MAPPING); - if (matcher instanceof ExtensionFileNameMatcher) { - mapping.setAttribute(ATTRIBUTE_EXT, ((ExtensionFileNameMatcher)matcher).getExtension()); - } - else if (writePattern(matcher, mapping)) { - return null; - } - if (approved) { - mapping.setAttribute(ATTRIBUTE_APPROVED, "true"); - } - if (specifyTypeName) { - mapping.setAttribute(ATTRIBUTE_TYPE, type.getName()); - } - - return mapping; - } - - private static boolean writePattern(FileNameMatcher matcher, Element mapping) { + static boolean writePattern(FileNameMatcher matcher, Element mapping) { if (matcher instanceof WildcardFileNameMatcher) { mapping.setAttribute(ATTRIBUTE_PATTERN, ((WildcardFileNameMatcher)matcher).getPattern()); } diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java index 4a7bfeb7587b..1b2b4e1fa80c 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/ApproveRemovedMappingsActivity.java @@ -12,14 +12,12 @@ import com.intellij.openapi.fileTypes.FileTypeManager; import com.intellij.openapi.fileTypes.PlainTextFileType; import com.intellij.openapi.project.Project; import com.intellij.openapi.startup.StartupActivity; -import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.registry.Registry; import com.intellij.util.ui.UIUtil; import org.jetbrains.annotations.NotNull; import javax.swing.event.HyperlinkEvent; -import java.util.Iterator; -import java.util.Map; +import java.util.List; /** * @author Dmitry Avdeev @@ -29,16 +27,13 @@ public class ApproveRemovedMappingsActivity implements StartupActivity { public void runActivity(@NotNull final Project project) { if (ApplicationManager.getApplication().isUnitTestMode() || !Registry.is("ide.restore.removed.mappings")) return; - final Map> map = ((FileTypeManagerImpl)FileTypeManager.getInstance()).getRemovedMappings(); - if (!map.isEmpty()) { + RemovedMappingTracker removedMappings = ((FileTypeManagerImpl)FileTypeManager.getInstance()).getRemovedMappingTracker(); + List list = removedMappings.retrieveUnapprovedMappings(); + if (!list.isEmpty()) { UIUtil.invokeAndWaitIfNeeded((Runnable)() -> { - for (Iterator>> iterator = map.entrySet().iterator(); iterator.hasNext(); ) { - Map.Entry> entry = iterator.next(); - if (entry.getValue().getSecond()) { - continue; - } - final FileNameMatcher matcher = entry.getKey(); - final FileType fileType = entry.getValue().getFirst(); + for (RemovedMappingTracker.RemovedMapping mapping : list) { + final FileNameMatcher matcher = mapping.getFileNameMatcher(); + final FileType fileType = FileTypeManager.getInstance().findFileTypeByName(mapping.getFileTypeName()); Notification notification = new Notification("File type recognized", "File type recognized", "File extension " + matcher.getPresentableString() + " was reassigned to " + fileType.getName() + " Revert", @@ -47,14 +42,13 @@ public class ApproveRemovedMappingsActivity implements StartupActivity { protected void hyperlinkActivated(@NotNull Notification notification, @NotNull HyperlinkEvent e) { ApplicationManager.getApplication().runWriteAction(() -> { FileTypeManager.getInstance().associate(PlainTextFileType.INSTANCE, matcher); - map.put(matcher, Pair.create(fileType, true)); + removedMappings.add(matcher, fileType.getName(), true); }); notification.expire(); } }); Notifications.Bus.notify(notification, project); ApplicationManager.getApplication().runWriteAction(() -> FileTypeManager.getInstance().associate(fileType, matcher)); - iterator.remove(); } }); } diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java index 76a27418fc2e..e43456ed27bb 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/FileTypeManagerImpl.java @@ -103,9 +103,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent private final FileTypeAssocTable myInitialAssociations = new FileTypeAssocTable<>(); private final Map myUnresolvedMappings = new THashMap<>(); - private final Map> myUnresolvedRemovedMappings = new THashMap<>(); - /** This will contain removed mappings with "approved" states */ - private final Map> myRemovedMappings = new THashMap<>(); + private final RemovedMappingTracker myRemovedMappingTracker = new RemovedMappingTracker(); @NonNls private static final String ELEMENT_FILETYPE = "filetype"; @NonNls private static final String ELEMENT_IGNORE_FILES = "ignoreFiles"; @@ -1127,7 +1125,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent if (PlainTextFileType.INSTANCE == type) { FileType newFileType = myPatternsTable.findAssociatedFileType(matcher); if (newFileType != null && newFileType != PlainTextFileType.INSTANCE && newFileType != UnknownFileType.INSTANCE) { - myRemovedMappings.put(matcher, Pair.create(newFileType, false)); + myRemovedMappingTracker.add(matcher, newFileType.getName(), false); } } associate(type, matcher, false); @@ -1140,16 +1138,11 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent } } - List> removedAssociations = AbstractFileType.readRemovedAssociations(e); - for (Trinity trinity : removedAssociations) { - FileType type = getFileTypeByName(trinity.getSecond()); - FileNameMatcher matcher = trinity.getFirst(); - if (type != null) { - removeAssociation(type, matcher, false); - myRemovedMappings.put(matcher, Pair.create(type, trinity.third)); - } - else { - myUnresolvedRemovedMappings.put(matcher, Trinity.create(trinity.getSecond(), myUnresolvedMappings.get(matcher), trinity.getThird())); + myRemovedMappingTracker.load(e); + for (RemovedMappingTracker.RemovedMapping mapping : myRemovedMappingTracker.getRemovedMappings()) { + FileType fileType = getFileTypeByName(mapping.getFileTypeName()); + if (fileType != null) { + removeAssociation(fileType, mapping.getFileNameMatcher(), false); } } } @@ -1215,13 +1208,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent } // https://youtrack.jetbrains.com/issue/IDEA-138366 - for (Map.Entry> entry : myRemovedMappings.entrySet()) { - Pair value = entry.getValue(); - Element content = AbstractFileType.writeRemovedMapping(value.first, entry.getKey(), true, value.second); - if (content != null) { - map.addContent(content); - } - } + myRemovedMappingTracker.save(map); if (!myUnresolvedMappings.isEmpty()) { FileNameMatcher[] unresolvedMappingKeys = myUnresolvedMappings.keySet().toArray(new FileNameMatcher[0]); @@ -1259,23 +1246,13 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent } } - for (FileNameMatcher matcher : defaultAssociations) { - Element content = AbstractFileType.writeRemovedMapping(type, matcher, specifyTypeName, isApproved(matcher)); - if (content != null) { - map.addContent(content); - } - } - } - - private boolean isApproved(@NotNull FileNameMatcher matcher) { - Pair pair = myRemovedMappings.get(matcher); - return pair != null && pair.getSecond(); + myRemovedMappingTracker.saveRemovedMappingsForFileType(map, type.getName(), defaultAssociations, specifyTypeName); } public void approveRemoval(@NotNull FileNameMatcher matcher) { FileType type = getExtensionMap().findAssociatedFileType(matcher); if (type != null) { - myRemovedMappings.put(matcher, Pair.create(type, true)); + myRemovedMappingTracker.approveRemoval(type.getName(), matcher); } } @@ -1328,12 +1305,8 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent } } - for (FileNameMatcher matcher : new THashSet<>(myUnresolvedRemovedMappings.keySet())) { - Trinity trinity = myUnresolvedRemovedMappings.get(matcher); - if (Comparing.equal(trinity.getFirst(), fileType.getName())) { - removeAssociation(fileType, matcher, false); - myUnresolvedRemovedMappings.remove(matcher); - } + for (FileNameMatcher matcher : myRemovedMappingTracker.getMappingsForFileType(fileType.getName())) { + removeAssociation(fileType, matcher, false); } } @@ -1389,8 +1362,8 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent associate(type, association.getFirst(), false); } - for (Trinity removedAssociation : AbstractFileType.readRemovedAssociations(extensions)) { - removeAssociation(type, removedAssociation.getFirst(), false); + for (RemovedMappingTracker.RemovedMapping removedAssociation : RemovedMappingTracker.readRemovedMappings(extensions)) { + removeAssociation(type, removedAssociation.getFileNameMatcher(), false); } } } @@ -1459,14 +1432,12 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent myPatternsTable = assocTable.copy(); fireFileTypesChanged(); - Iterator>> iterator = myRemovedMappings.entrySet().iterator(); - while (iterator.hasNext()) { - Map.Entry> entry = iterator.next(); - if (assocTable.isAssociatedWith(entry.getValue().first, entry.getKey())) - iterator.remove(); - } + myRemovedMappingTracker.removeMatching((matcher, fileTypeName) -> { + FileType fileType = getFileTypeByName(fileTypeName); + return fileType != null && assocTable.isAssociatedWith(fileType, matcher); + }); for (FileNameMatcher matcher : removedMappings.keySet()) { - myRemovedMappings.put(matcher, Pair.create(removedMappings.get(matcher), true)); + myRemovedMappingTracker.add(matcher, removedMappings.get(matcher).getName(), true); } } @@ -1514,27 +1485,28 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent FileType fileType = pair.fileType; if (fileType == PlainTextFileType.INSTANCE) return; for (FileNameMatcher matcher : pair.matchers) { - registerReDetectedMapping(fileType, matcher); + registerReDetectedMapping(fileType.getName(), matcher); if (matcher instanceof ExtensionFileNameMatcher) { // also check exact file name matcher ExtensionFileNameMatcher extMatcher = (ExtensionFileNameMatcher)matcher; - registerReDetectedMapping(fileType, new ExactFileNameMatcher("." + extMatcher.getExtension())); + registerReDetectedMapping(fileType.getName(), new ExactFileNameMatcher("." + extMatcher.getExtension())); } } } - private void registerReDetectedMapping(@NotNull FileType fileType, @NotNull FileNameMatcher matcher) { + private void registerReDetectedMapping(String fileTypeName, @NotNull FileNameMatcher matcher) { String typeName = myUnresolvedMappings.get(matcher); - if (typeName != null && !typeName.equals(fileType.getName())) { - Trinity trinity = myUnresolvedRemovedMappings.get(matcher); - myRemovedMappings.put(matcher, Pair.create(fileType, trinity != null && trinity.third)); + if (typeName != null && !typeName.equals(fileTypeName)) { + if (!myRemovedMappingTracker.hasRemovedMapping(matcher)) { + myRemovedMappingTracker.add(matcher, fileTypeName, false); + } myUnresolvedMappings.remove(matcher); } } @NotNull - Map> getRemovedMappings() { - return myRemovedMappings; + RemovedMappingTracker getRemovedMappingTracker() { + return myRemovedMappingTracker; } @TestOnly @@ -1544,7 +1516,7 @@ public class FileTypeManagerImpl extends FileTypeManagerEx implements Persistent } myStandardFileTypes.clear(); myUnresolvedMappings.clear(); - myRemovedMappings.clear(); + myRemovedMappingTracker.clear(); mySchemeManager.setSchemes(Collections.emptyList()); } diff --git a/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java new file mode 100644 index 000000000000..7760a3d086c1 --- /dev/null +++ b/platform/platform-impl/src/com/intellij/openapi/fileTypes/impl/RemovedMappingTracker.java @@ -0,0 +1,171 @@ +// 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.openapi.fileTypes.impl; + +import com.intellij.openapi.fileTypes.ExtensionFileNameMatcher; +import com.intellij.openapi.fileTypes.FileNameMatcher; +import com.intellij.openapi.fileTypes.FileTypeManager; +import org.jdom.Element; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; + +import java.util.*; +import java.util.function.BiPredicate; + +class RemovedMappingTracker { + public static class RemovedMapping { + private final FileNameMatcher myFileNameMatcher; + private final String myFileTypeName; + private boolean myApproved; + + private RemovedMapping(FileNameMatcher matcher, String name, boolean approved) { + myFileNameMatcher = matcher; + myFileTypeName = name; + myApproved = approved; + } + + public FileNameMatcher getFileNameMatcher() { + return myFileNameMatcher; + } + + public String getFileTypeName() { + return myFileTypeName; + } + + public boolean isApproved() { + return myApproved; + } + + public void setApproved(boolean approved) { + myApproved = approved; + } + } + + private final Map myRemovedMappings = new HashMap<>(); + + @NonNls private static final String ELEMENT_REMOVED_MAPPING = "removed_mapping"; + /** Applied for removed mappings approved by user */ + @NonNls private static final String ATTRIBUTE_APPROVED = "approved"; + @NonNls static final String ATTRIBUTE_TYPE = "type"; + + void clear() { + myRemovedMappings.clear(); + } + + public void add(FileNameMatcher matcher, String fileTypeName, boolean approved) { + myRemovedMappings.put(matcher, new RemovedMapping(matcher, fileTypeName, approved)); + } + + public void load(@NotNull Element e) { + for (RemovedMapping mapping : readRemovedMappings(e)) { + myRemovedMappings.put(mapping.myFileNameMatcher, mapping); + } + } + + @NotNull + static List readRemovedMappings(@NotNull Element e) { + List children = e.getChildren(ELEMENT_REMOVED_MAPPING); + if (children.isEmpty()) { + return Collections.emptyList(); + } + + List result = new ArrayList<>(); + for (Element mapping : children) { + String ext = mapping.getAttributeValue(AbstractFileType.ATTRIBUTE_EXT); + FileNameMatcher matcher = ext == null ? FileTypeManager.parseFromString(mapping.getAttributeValue(AbstractFileType.ATTRIBUTE_PATTERN)) : new ExtensionFileNameMatcher(ext); + boolean approved = Boolean.parseBoolean(mapping.getAttributeValue(ATTRIBUTE_APPROVED)); + String fileTypeName = mapping.getAttributeValue(ATTRIBUTE_TYPE); + if (fileTypeName == null) continue; + + RemovedMapping removedMapping = new RemovedMapping(matcher, fileTypeName, approved); + result.add(removedMapping); + } + return result; + } + + public void save(Element element) { + for (RemovedMapping mapping : myRemovedMappings.values()) { + Element content = writeRemovedMapping(mapping.myFileTypeName, mapping.myFileNameMatcher, true, mapping.myApproved); + if (content != null) { + element.addContent(content); + } + } + } + + public void saveRemovedMappingsForFileType(Element map, String fileTypeName, Set associations, boolean specifyTypeName) { + for (FileNameMatcher matcher : associations) { + Element content = writeRemovedMapping(fileTypeName, matcher, specifyTypeName, isApproved(matcher)); + if (content != null) { + map.addContent(content); + } + } + } + + boolean hasRemovedMapping(FileNameMatcher matcher) { + return myRemovedMappings.containsKey(matcher); + } + + boolean isApproved(FileNameMatcher matcher) { + RemovedMapping mapping = myRemovedMappings.get(matcher); + return mapping != null && mapping.isApproved(); + } + + public void approveRemoval(String fileTypeName, FileNameMatcher matcher) { + myRemovedMappings.put(matcher, new RemovedMapping(matcher, fileTypeName, true)); + } + + public List getRemovedMappings() { + return new ArrayList<>(myRemovedMappings.values()); + } + + public List getMappingsForFileType(String name) { + List result = new ArrayList<>(); + for (RemovedMapping mapping : myRemovedMappings.values()) { + if (mapping.myFileTypeName.equals(name)) { + result.add(mapping.myFileNameMatcher); + } + } + return result; + } + + void removeMatching(BiPredicate predicate) { + for (Iterator> it = myRemovedMappings.entrySet().iterator(); it.hasNext(); ) { + Map.Entry next = it.next(); + if (predicate.test(next.getValue().myFileNameMatcher, next.getValue().myFileTypeName)) { + it.remove(); + } + } + } + + List retrieveUnapprovedMappings() { + List result = new ArrayList<>(); + for (Iterator> it = myRemovedMappings.entrySet().iterator(); it.hasNext(); ) { + Map.Entry next = it.next(); + if (!next.getValue().isApproved()) { + result.add(next.getValue()); + it.remove(); + } + } + return result; + } + + static Element writeRemovedMapping(@NotNull String fileTypeName, + @NotNull FileNameMatcher matcher, + boolean specifyTypeName, + boolean approved) { + Element mapping = new Element(ELEMENT_REMOVED_MAPPING); + if (matcher instanceof ExtensionFileNameMatcher) { + mapping.setAttribute(AbstractFileType.ATTRIBUTE_EXT, ((ExtensionFileNameMatcher)matcher).getExtension()); + } + else if (AbstractFileType.writePattern(matcher, mapping)) { + return null; + } + if (approved) { + mapping.setAttribute(ATTRIBUTE_APPROVED, "true"); + } + if (specifyTypeName) { + mapping.setAttribute(ATTRIBUTE_TYPE, fileTypeName); + } + + return mapping; + } +} diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java index 5d1e5e73fdb1..c625d262ecef 100644 --- a/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java +++ b/platform/platform-tests/testSrc/com/intellij/openapi/fileTypes/impl/FileTypesTest.java @@ -377,19 +377,19 @@ public class FileTypesTest extends PlatformTestCase { table.removeAssociation(matcher, fileType); WriteAction.run(() -> myFileTypeManager.setPatternsTable(fileTypes, table)); - myFileTypeManager.getRemovedMappings().put(matcher, Pair.create(fileType, true)); + myFileTypeManager.getRemovedMappingTracker().add(matcher, fileType.getName(), true); Element state = myFileTypeManager.getState(); - myFileTypeManager.getRemovedMappings().clear(); + myFileTypeManager.getRemovedMappingTracker().clear(); myFileTypeManager.initStandardFileTypes(); myFileTypeManager.loadState(state); myFileTypeManager.initializeComponent(); - Map> mappings = myFileTypeManager.getRemovedMappings(); - Pair pair = mappings.get(matcher); - assertNotNull(pair); - assertTrue(pair.second); + List mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings(); + assertEquals(1, mappings.size()); + assertTrue(mappings.get(0).isApproved()); + assertEquals(matcher, mappings.get(0).getFileNameMatcher()); } public void testRemovedExactNameMapping() { @@ -403,19 +403,18 @@ public class FileTypesTest extends PlatformTestCase { table.removeAssociation(matcher, fileType); WriteAction.run(() -> myFileTypeManager.setPatternsTable(fileTypes, table)); - myFileTypeManager.getRemovedMappings().put(matcher, Pair.create(fileType, true)); + myFileTypeManager.getRemovedMappingTracker().add(matcher, fileType.getName(), true); Element state = myFileTypeManager.getState(); - myFileTypeManager.getRemovedMappings().clear(); + myFileTypeManager.getRemovedMappingTracker().clear(); myFileTypeManager.initStandardFileTypes(); myFileTypeManager.loadState(state); myFileTypeManager.initializeComponent(); - Map> mappings = myFileTypeManager.getRemovedMappings(); - Pair pair = mappings.get(matcher); - assertNotNull(pair); - assertTrue(pair.second); + List mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings(); + assertTrue(mappings.get(0).isApproved()); + assertEquals(matcher, mappings.get(0).getFileNameMatcher()); } public void testReassignedPredefinedFileType() { @@ -428,18 +427,18 @@ public class FileTypesTest extends PlatformTestCase { public void testReAddedMapping() { ArchiveFileType fileType = ArchiveFileType.INSTANCE; FileNameMatcher matcher = myFileTypeManager.getAssociations(fileType).get(0); - myFileTypeManager.getRemovedMappings().put(matcher, Pair.create(fileType, true)); + myFileTypeManager.getRemovedMappingTracker().add(matcher, fileType.getName(), true); WriteAction.run(() -> myFileTypeManager .setPatternsTable(new HashSet<>(Arrays.asList(myFileTypeManager.getRegisteredFileTypes())), myFileTypeManager.getExtensionMap().copy())); - assertEquals(0, myFileTypeManager.getRemovedMappings().size()); + assertEquals(0, myFileTypeManager.getRemovedMappingTracker().getRemovedMappings().size()); } public void testPreserveRemovedMappingForUnknownFileType() { - myFileTypeManager.getRemovedMappings().put(new ExtensionFileNameMatcher("xxx"), Pair.create(createTestFileType(), true)); + myFileTypeManager.getRemovedMappingTracker().add(new ExtensionFileNameMatcher("xxx"), "Foo Files", true); WriteAction.run(() -> myFileTypeManager .setPatternsTable(new HashSet<>(Arrays.asList(myFileTypeManager.getRegisteredFileTypes())), myFileTypeManager.getExtensionMap().copy())); - assertEquals(1, myFileTypeManager.getRemovedMappings().size()); + assertEquals(1, myFileTypeManager.getRemovedMappingTracker().getRemovedMappings().size()); } public void testGetRemovedMappings() { @@ -492,9 +491,9 @@ public class FileTypesTest extends PlatformTestCase { myFileTypeManager.loadState(element); myFileTypeManager.initializeComponent(); - Map> mappings = myFileTypeManager.getRemovedMappings(); + List mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings(); assertEquals(1, mappings.size()); - assertEquals(typeFromPlugin, mappings.values().iterator().next().first); + assertEquals(typeFromPlugin.getName(), mappings.get(0).getFileTypeName()); } public void testPreserveUninstalledPluginAssociations() { @@ -562,10 +561,10 @@ public class FileTypesTest extends PlatformTestCase { myFileTypeManager.loadState(element); myFileTypeManager.initializeComponent(); - Map> mappings = myFileTypeManager.getRemovedMappings(); + List mappings = myFileTypeManager.getRemovedMappingTracker().getRemovedMappings(); assertEquals(1, mappings.size()); - assertEquals(ArchiveFileType.INSTANCE, mappings.values().iterator().next().first); - mappings.clear(); + assertEquals(ArchiveFileType.INSTANCE.getName(), mappings.get(0).getFileTypeName()); + myFileTypeManager.getRemovedMappingTracker().clear(); assertEquals(ArchiveFileType.INSTANCE, myFileTypeManager.getFileTypeByExtension("zip")); Element map = myFileTypeManager.getState().getChild("extensionMap"); if (map != null) {