[vcs]: provide separated ignored maps for vcses and one for Ide ignored

* rename;
* return Composite Ignored holder from FileHolder instead of common
 instance;
* add annotations;
* provider getter for active ignored files holder for current VCS;
* use streams if possible;

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ChangeListManagerImpl.java

@@ -403,7 +403,7 @@ public class ChangeListManagerImpl extends ChangeListManagerEx implements Projec
     final Set<VirtualFile> refreshFiles = new HashSet<>();
     try {
       synchronized (myDataLock) {
-        final IgnoredFilesHolder fileHolder = (IgnoredFilesHolder)myComposite.get(FileHolder.HolderType.IGNORED);
+        final IgnoredFilesCompositeHolder fileHolder = myComposite.getIgnoredFileHolder();
 
         for (Iterator<VcsDirtyScope> iterator = scopes.iterator(); iterator.hasNext(); ) {
           final VcsModifiableDirtyScope scope = (VcsModifiableDirtyScope)iterator.next();
@@ -805,7 +805,8 @@ public class ChangeListManagerImpl extends ChangeListManagerEx implements Projec
   /**
    * @return only roots for ignored folders, and ignored files
    */
-  List<VirtualFile> getIgnoredFiles() {
+  @NotNull
+  public List<VirtualFile> getIgnoredFiles() {
     synchronized (myDataLock) {
       return new ArrayList<>(myComposite.getIgnoredFileHolder().values());
     }

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/FileHolderComposite.java

@@ -100,8 +100,8 @@ public class FileHolderComposite implements FileHolder {
     throw new UnsupportedOperationException();
   }
 
-  public IgnoredFilesHolder getIgnoredFileHolder() {
-    return (IgnoredFilesHolder) myHolders.get(HolderType.IGNORED);
+  public IgnoredFilesCompositeHolder getIgnoredFileHolder() {
+    return (IgnoredFilesCompositeHolder) myHolders.get(HolderType.IGNORED);
   }
 
   public void notifyVcsStarted(AbstractVcs vcs) {

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/IgnoredFilesCompositeHolder.java

@@ -15,52 +15,57 @@
  */
 package com.intellij.openapi.vcs.changes;
 
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vcs.AbstractVcs;
 import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.ObjectUtils;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class IgnoredFilesCompositeHolder implements IgnoredFilesHolder {
-  private final Map<AbstractVcs, IgnoredFilesHolder> myHolderMap;
+  private final Map<AbstractVcs, IgnoredFilesHolder> myVcsIgnoredHolderMap;
+  private IgnoredFilesHolder myIdeIgnoredFilesHolder;
   private final Project myProject;
   private AbstractVcs myCurrentVcs;
   private final ProjectLevelVcsManager myVcsManager;
-  private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vcs.changes.IgnoredFilesCompositeHolder");
 
   public IgnoredFilesCompositeHolder(final Project project) {
     super();
     myProject = project;
-    myHolderMap = new HashMap<>();
+    myVcsIgnoredHolderMap = new HashMap<>();
+    myIdeIgnoredFilesHolder = new RecursiveFileHolder<>(myProject, HolderType.IGNORED);
     myVcsManager = ProjectLevelVcsManager.getInstance(myProject);
   }
 
   @Override
   public void cleanAll() {
-    myHolderMap.clear();
+    myVcsIgnoredHolderMap.clear();
+    myIdeIgnoredFilesHolder.cleanAll();
   }
 
   @Override
   public void cleanAndAdjustScope(VcsModifiableDirtyScope scope) {
     final AbstractVcs vcs = scope.getVcs();
-    if (myHolderMap.containsKey(vcs)) {
-      myHolderMap.get(vcs).cleanAndAdjustScope(scope);
+    if (myVcsIgnoredHolderMap.containsKey(vcs)) {
+      myVcsIgnoredHolderMap.get(vcs).cleanAndAdjustScope(scope);
     }
+    myIdeIgnoredFilesHolder.cleanAndAdjustScope(scope);
   }
 
   @Override
   public FileHolder copy() {
     final IgnoredFilesCompositeHolder result = new IgnoredFilesCompositeHolder(myProject);
-    for (Map.Entry<AbstractVcs, IgnoredFilesHolder> entry : myHolderMap.entrySet()) {
-      result.myHolderMap.put(entry.getKey(), (IgnoredFilesHolder) entry.getValue().copy());
+    for (Map.Entry<AbstractVcs, IgnoredFilesHolder> entry : myVcsIgnoredHolderMap.entrySet()) {
+      result.myVcsIgnoredHolderMap.put(entry.getKey(), (IgnoredFilesHolder)entry.getValue().copy());
     }
+    result.myIdeIgnoredFilesHolder = (IgnoredFilesHolder)myIdeIgnoredFilesHolder.copy();
     return result;
   }
 
@@ -71,39 +76,46 @@ public class IgnoredFilesCompositeHolder implements IgnoredFilesHolder {
 
   @Override
   public void addFile(VirtualFile file) {
-    if (!myHolderMap.containsKey(myCurrentVcs)) {
-      LOG.error("current vcs: " + myCurrentVcs + " file: " + file.getPath());
-    }
-    myHolderMap.get(myCurrentVcs).addFile(file);
+    myIdeIgnoredFilesHolder.addFile(file);
   }
 
   @Override
   public boolean containsFile(VirtualFile file) {
+    if (myIdeIgnoredFilesHolder.containsFile(file)) return true;
     final AbstractVcs vcs = myVcsManager.getVcsFor(file);
     if (vcs == null) return false;
-    final IgnoredFilesHolder ignoredFilesHolder = myHolderMap.get(vcs);
+    final IgnoredFilesHolder ignoredFilesHolder = myVcsIgnoredHolderMap.get(vcs);
     return ignoredFilesHolder != null && ignoredFilesHolder.containsFile(file);
   }
 
   @Override
   public Collection<VirtualFile> values() {
-    if (myHolderMap.size() == 1) return myHolderMap.values().iterator().next().values();
-    final HashSet<VirtualFile> result = new HashSet<>();
-    for (IgnoredFilesHolder holder : myHolderMap.values()) {
-      result.addAll(holder.values());
-    }
+    final HashSet<VirtualFile> result = ContainerUtil.newHashSet();
+    result.addAll(myIdeIgnoredFilesHolder.values());
+    result.addAll(myVcsIgnoredHolderMap.values().stream().map(IgnoredFilesHolder::values).flatMap(set -> set.stream()).collect(Collectors.toSet()));
     return result;
   }
 
   @Override
   public void notifyVcsStarted(AbstractVcs vcs) {
     myCurrentVcs = vcs;
-    if (myHolderMap.containsKey(vcs)) return;
+    if (myVcsIgnoredHolderMap.containsKey(vcs)) return;
 
     IgnoredFilesHolder ignoredFilesHolder =
       ObjectUtils.chooseNotNull(getHolderFromEP(vcs, myProject), new RecursiveFileHolder<>(myProject, HolderType.IGNORED));
     ignoredFilesHolder.notifyVcsStarted(vcs);
-    myHolderMap.put(vcs, ignoredFilesHolder);
+    myVcsIgnoredHolderMap.put(vcs, ignoredFilesHolder);
+  }
+
+  @Nullable
+  public IgnoredFilesHolder getActiveVcsHolder() {
+    return getIgnoredHolderByVcs(myCurrentVcs);
+  }
+
+  @Nullable
+  private IgnoredFilesHolder getIgnoredHolderByVcs(AbstractVcs vcs) {
+    if (!myVcsIgnoredHolderMap.containsKey(vcs)) return null;
+    return myVcsIgnoredHolderMap.get(vcs);
   }
 
 
@@ -124,13 +136,12 @@ public class IgnoredFilesCompositeHolder implements IgnoredFilesHolder {
     if (!(obj instanceof IgnoredFilesCompositeHolder)) {
       return false;
     }
-    IgnoredFilesCompositeHolder other = (IgnoredFilesCompositeHolder) obj;
-    return myHolderMap.equals(other.myHolderMap);
+    IgnoredFilesCompositeHolder other = (IgnoredFilesCompositeHolder)obj;
+    return myVcsIgnoredHolderMap.equals(other.myVcsIgnoredHolderMap) && myIdeIgnoredFilesHolder.equals(other.myIdeIgnoredFilesHolder);
   }
 
   @Override
   public int hashCode() {
-    return myHolderMap.hashCode();
+    return Objects.hash(myVcsIgnoredHolderMap, myIdeIgnoredFilesHolder);
   }
-
 }

platform/vcs-impl/src/com/intellij/openapi/vcs/changes/UpdatingChangeListBuilder.java

@@ -25,6 +25,7 @@ import com.intellij.openapi.vcs.FilePath;
 import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vcs.VcsKey;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.util.ObjectUtils;
 import com.intellij.vcsUtil.VcsUtil;
 import org.jetbrains.annotations.Nullable;
 
@@ -174,7 +175,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
     checkIfDisposed();
     if (isIgnoredByVcs(file)) return;
     if (myScope.belongsTo(VcsUtil.getFilePath(file))) {
-      myComposite.getIgnoredFileHolder().addFile(file);
+      ObjectUtils.assertNotNull(myComposite.getIgnoredFileHolder().getActiveVcsHolder()).addFile(file);
     }
   }