vcs: extracted 'isExcluded' checks to a separate method

2026-09-27 10:03:11 +07:00 · 2014-07-23 12:20:42 +04:00
parent fed971c173
commit a4f780bb8f
13 changed files with 78 additions and 85 deletions
@@ -272,6 +272,7 @@ public abstract class ProjectLevelVcsManager {
  public abstract VcsHistoryCache getVcsHistoryCache();
  public abstract ContentRevisionCache getContentRevisionCache();
  public abstract boolean isFileInContent(final VirtualFile vf);
+  public abstract boolean isIgnoredByVcs(VirtualFile vf);

  public abstract boolean dvcsUsedInProject();

@@ -1,14 +1,13 @@
 package com.intellij.openapi.vcs.changes;

-import com.intellij.lifecycle.PeriodicalTasksCloser;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.FileIndexFacade;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.registry.Registry;
 import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vcs.history.VcsRevisionNumber;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.containers.OpenTHashSet;
@@ -147,12 +146,12 @@ public class LocalChangeListImpl extends LocalChangeList {
    createReadChangesCache();
    final Collection<Change> result = new ArrayList<Change>();
    myChangesBeforeUpdate = new OpenTHashSet<Change>(myChanges);
-    final FileIndexFacade fileIndex = PeriodicalTasksCloser.getInstance().safeGetService(project, FileIndexFacade.class);
+    final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
    for (Change oldBoy : myChangesBeforeUpdate) {
      final ContentRevision before = oldBoy.getBeforeRevision();
      final ContentRevision after = oldBoy.getAfterRevision();
      if (scope == null || before != null && scope.belongsTo(before.getFile()) || after != null && scope.belongsTo(after.getFile())
-        || isIgnoredChange(oldBoy, fileIndex)) {
+        || isIgnoredChange(oldBoy, vcsManager)) {
        result.add(oldBoy);
        myChanges.remove(oldBoy);
        myReadChangesCache = null;
@@ -161,18 +160,18 @@ public class LocalChangeListImpl extends LocalChangeList {
    return result;
  }

-  private static boolean isIgnoredChange(final Change change, final FileIndexFacade fileIndex) {
-    boolean beforeRevIgnored = change.getBeforeRevision() == null || isIgnoredRevision(change.getBeforeRevision(), fileIndex);
-    boolean afterRevIgnored = change.getAfterRevision() == null || isIgnoredRevision(change.getAfterRevision(), fileIndex);
+  private static boolean isIgnoredChange(final Change change, final ProjectLevelVcsManager vcsManager) {
+    boolean beforeRevIgnored = change.getBeforeRevision() == null || isIgnoredRevision(change.getBeforeRevision(), vcsManager);
+    boolean afterRevIgnored = change.getAfterRevision() == null || isIgnoredRevision(change.getAfterRevision(), vcsManager);
    return beforeRevIgnored && afterRevIgnored;
  }

-  private static boolean isIgnoredRevision(final ContentRevision revision, final FileIndexFacade fileIndex) {
+  private static boolean isIgnoredRevision(final ContentRevision revision, final ProjectLevelVcsManager vcsManager) {
    return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
      @Override
      public Boolean compute() {
        VirtualFile vFile = revision.getFile().getVirtualFile();
-        return vFile != null && fileIndex.isExcludedFile(vFile);
+        return vFile != null && vcsManager.isIgnoredByVcs(vFile);
      }
    });
  }
@@ -15,16 +15,15 @@
 */
 package com.intellij.openapi.vcs.changes;

-import com.intellij.lifecycle.PeriodicalTasksCloser;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileTypes.FileTypeManager;
-import com.intellij.openapi.roots.FileIndexFacade;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Factory;
 import com.intellij.openapi.util.Getter;
 import com.intellij.openapi.vcs.FilePath;
 import com.intellij.openapi.vcs.FilePathImpl;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vcs.VcsKey;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.Nullable;
@@ -40,7 +39,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
  private VcsDirtyScope myScope;
  private FoldersCutDownWorker myFoldersCutDownWorker;
  private final IgnoredFilesComponent myIgnoredFilesComponent;
-  private final FileIndexFacade myIndex;
+  private final ProjectLevelVcsManager myVcsManager;
  private final ChangeListManagerGate myGate;
  private Factory<JComponent> myAdditionalInfo;

@@ -53,7 +52,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
    myDisposedGetter = disposedGetter;
    myIgnoredFilesComponent = ignoredFilesComponent;
    myGate = gate;
-    myIndex = PeriodicalTasksCloser.getInstance().safeGetService(changeListWorker.getProject(), FileIndexFacade.class);
+    myVcsManager = ProjectLevelVcsManager.getInstance(changeListWorker.getProject());
  }

  private void checkIfDisposed() {
@@ -117,12 +116,12 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
    myChangeListWorker.removeRegisteredChangeFor(path);
  }

-  private boolean isExcluded(final VirtualFile file) {
+  private boolean isIgnoredByVcs(final VirtualFile file) {
    return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
      @Override
      public Boolean compute() {
        checkIfDisposed();
-        return myIndex.isExcludedFile(file);
+        return myVcsManager.isIgnoredByVcs(file);
      }
    });
  }
@@ -133,7 +132,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
    }
    if (file == null) return;
    checkIfDisposed();
-    if (isExcluded(file)) return;
+    if (isIgnoredByVcs(file)) return;
    if (myScope.belongsTo(new FilePathImpl(file))) {
      if (myIgnoredFilesComponent.isIgnoredFile(file)) {
        myComposite.getIgnoredFileHolder().addFile(file);
@@ -165,7 +164,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
  public void processModifiedWithoutCheckout(final VirtualFile file) {
    if (file == null) return;
    checkIfDisposed();
-    if (isExcluded(file)) return;
+    if (isIgnoredByVcs(file)) return;
    if (myScope.belongsTo(new FilePathImpl(file))) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("processModifiedWithoutCheckout " + file);
@@ -177,7 +176,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
  public void processIgnoredFile(final VirtualFile file) {
    if (file == null) return;
    checkIfDisposed();
-    if (isExcluded(file)) return;
+    if (isIgnoredByVcs(file)) return;
    if (myScope.belongsTo(new FilePathImpl(file))) {
      IgnoredFilesHolder ignoredFilesHolder = myComposite.getIgnoredFileHolder();
      if (ignoredFilesHolder instanceof IgnoredFilesCompositeHolder) {
@@ -212,7 +211,7 @@ class UpdatingChangeListBuilder implements ChangelistBuilder {
  public void processSwitchedFile(final VirtualFile file, final String branch, final boolean recursive) {
    if (file == null) return;
    checkIfDisposed();
-    if (isExcluded(file)) return;
+    if (isIgnoredByVcs(file)) return;
    if (myScope.belongsTo(new FilePathImpl(file))) {
      myChangeListWorker.addSwitched(file, branch, recursive);
    }
@@ -73,7 +73,7 @@ public class VcsGuess {
        final boolean inContent = myVcsManager.isFileInContent(validParent);
        if (inContent) return true;
        if (filePath != null) {
-          return isFileInBaseDir(filePath, myProject.getBaseDir()) && !myExcludedFileIndex.isExcludedFile(validParent);
+          return isFileInBaseDir(filePath, myProject.getBaseDir()) && !myVcsManager.isIgnoredByVcs(validParent);
        }
        return false;
      }
@@ -132,7 +132,7 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme

    myBackgroundableActionHandlerMap = new EnumMap<VcsBackgroundableActions, BackgroundableActionEnabledHandler>(VcsBackgroundableActions.class);
    myInitialization = new VcsInitialization(myProject);
-    myMappings = new NewMappings(myProject, myMessageBus, this, manager, excludedFileIndex);
+    myMappings = new NewMappings(myProject, myMessageBus, this, manager);
    myMappingsToRoots = new MappingsToRoots(myMappings, myProject);

    if (!myProject.isDefault()) {
@@ -843,11 +843,16 @@ public class ProjectLevelVcsManagerImpl extends ProjectLevelVcsManagerEx impleme
      @Override
      public Boolean compute() {
        return vf != null && (myExcludedIndex.isInContent(vf) || isFileInBaseDir(vf) || vf.equals(myProject.getBaseDir()) ||
-                              hasExplicitMapping(vf) || isInDirectoryBasedRoot(vf)) && !myExcludedIndex.isExcludedFile(vf);
+                              hasExplicitMapping(vf) || isInDirectoryBasedRoot(vf)) && !isIgnoredByVcs(vf);
      }
    });
  }

+  @Override
+  public boolean isIgnoredByVcs(VirtualFile vf) {
+    return myExcludedIndex.isExcludedFile(vf);
+  }
+
  @Override
  public boolean dvcsUsedInProject() {
    AbstractVcs[] allActiveVcss = getAllActiveVcss();
@@ -36,14 +36,15 @@ public class VcsRootIterator {
  // folder path to files to be excluded
  private final Map<String, MyRootFilter> myOtherVcsFolders;
  private final FileIndexFacade myExcludedFileIndex;
+  private final ProjectLevelVcsManager myVcsManager;

  public VcsRootIterator(final Project project, final AbstractVcs vcs) {
-    final ProjectLevelVcsManager plVcsManager = ProjectLevelVcsManager.getInstance(project);
+    myVcsManager = ProjectLevelVcsManager.getInstance(project);
    myOtherVcsFolders = new HashMap<String, MyRootFilter>();
    myExcludedFileIndex = PeriodicalTasksCloser.getInstance().safeGetService(project, FileIndexFacade.class);

-    final VcsRoot[] allRoots = plVcsManager.getAllVcsRoots();
-    final VirtualFile[] roots = plVcsManager.getRootsUnderVcs(vcs);
+    final VcsRoot[] allRoots = myVcsManager.getAllVcsRoots();
+    final VirtualFile[] roots = myVcsManager.getRootsUnderVcs(vcs);
    for (VirtualFile root : roots) {
      final MyRootFilter rootPresentFilter = new MyRootFilter(root, vcs.getName());
      rootPresentFilter.init(allRoots);
@@ -57,14 +58,14 @@ public class VcsRootIterator {
    if ((rootFilter != null) && (!rootFilter.accept(file))) {
      return false;
    }
-    return !isExcluded(myExcludedFileIndex, file);
+    return !isIgnoredByVcs(myVcsManager, file);
  }

-  private static boolean isExcluded(final FileIndexFacade indexFacade, final VirtualFile file) {
+  private static boolean isIgnoredByVcs(final ProjectLevelVcsManager vcsManager, final VirtualFile file) {
    return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
      @Override
      public Boolean compute() {
-        return indexFacade.isExcludedFile(file);
+        return vcsManager.isIgnoredByVcs(file);
      }
    });
  }
@@ -140,7 +141,7 @@ public class VcsRootIterator {
    @Nullable private final VirtualFileFilter myDirectoryFilter;
    private final VirtualFile myRoot;
    private final MyRootFilter myRootPresentFilter;
-    private final FileIndexFacade myExcludedFileIndex;
+    private final ProjectLevelVcsManager myVcsManager;

    private MyRootIterator(final Project project,
                           final VirtualFile root,
@@ -153,13 +154,12 @@ public class VcsRootIterator {
      myDirectoryFilter = directoryFilter;
      myRoot = root;

-      final ProjectLevelVcsManager plVcsManager = ProjectLevelVcsManager.getInstance(project);
-      final AbstractVcs vcs = plVcsManager.getVcsFor(root);
-      myRootPresentFilter = (vcs == null) ? null : new MyRootFilter(root, vcs.getName());
+      myVcsManager = ProjectLevelVcsManager.getInstance(project);
+      final AbstractVcs vcs = myVcsManager.getVcsFor(root);
+      myRootPresentFilter = vcs == null ? null : new MyRootFilter(root, vcs.getName());
      if (myRootPresentFilter != null) {
-        myRootPresentFilter.init(ProjectLevelVcsManager.getInstance(myProject).getAllVcsRoots());
+        myRootPresentFilter.init(myVcsManager.getAllVcsRoots());
      }
-      myExcludedFileIndex = PeriodicalTasksCloser.getInstance().safeGetService(project, FileIndexFacade.class);
    }

    public void iterate() {
@@ -174,7 +174,7 @@ public class VcsRootIterator {
        @NotNull
        @Override
        public Result visitFileEx(@NotNull VirtualFile file) {
-          if (isExcluded(myExcludedFileIndex, file)) return SKIP_CHILDREN;
+          if (isIgnoredByVcs(myVcsManager, file)) return SKIP_CHILDREN;
          if (myRootPresentFilter != null && !myRootPresentFilter.accept(file)) return SKIP_CHILDREN;
          if (myProject.isDisposed() || !process(file)) return skipTo(myRoot);
          if (myDirectoryFilter != null && file.isDirectory() && !myDirectoryFilter.shouldGoIntoDirectory(file)) return SKIP_CHILDREN;
@@ -19,7 +19,6 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.DumbAwareRunnable;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.FileIndexFacade;
 import com.intellij.openapi.ui.MessageType;
 import com.intellij.openapi.util.EmptyRunnable;
 import com.intellij.openapi.util.Pair;
@@ -52,18 +51,18 @@ public class NewMappings {

  private final DefaultVcsRootPolicy myDefaultVcsRootPolicy;
  private final MessageBus myMessageBus;
+  private final ProjectLevelVcsManager myVcsManager;
  private final FileStatusManager myFileStatusManager;
-  private final FileIndexFacade myFileIndexFacade;
  private final Project myProject;

  private boolean myActivated;

-  public NewMappings(final Project project, final MessageBus messageBus,
-                     final ProjectLevelVcsManagerImpl vcsManager, FileStatusManager fileStatusManager, FileIndexFacade fileIndexFacade) {
+  public NewMappings(final Project project, final MessageBus messageBus, final ProjectLevelVcsManagerImpl vcsManager,
+                     FileStatusManager fileStatusManager) {
    myProject = project;
    myMessageBus = messageBus;
+    myVcsManager = vcsManager;
    myFileStatusManager = fileStatusManager;
-    myFileIndexFacade = fileIndexFacade;
    myLock = new Object();
    myVcsToPaths = new HashMap<String, List<VcsDirectoryMapping>>();
    myFileWatchRequestsManager = new FileWatchRequestsManager(myProject, this, LocalFileSystem.getInstance());
@@ -235,7 +234,7 @@ public class NewMappings {
  @Nullable
  public VcsDirectoryMapping getMappingFor(final VirtualFile file, final Object parentModule) {
    // if parentModule is not null it means that file belongs to the module so it isn't excluded
-    if (parentModule == null && myFileIndexFacade.isExcludedFile(file)) {
+    if (parentModule == null && myVcsManager.isIgnoredByVcs(file)) {
      return null;
    }

@@ -33,13 +33,8 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.fileTypes.FileTypeManager;
 import com.intellij.openapi.progress.ProgressIndicator;
-import com.intellij.openapi.roots.ProjectFileIndex;
-import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.vcs.FilePath;
-import com.intellij.openapi.vcs.FileStatus;
-import com.intellij.openapi.vcs.ObjectsConvertor;
-import com.intellij.openapi.vcs.VcsException;
+import com.intellij.openapi.vcs.*;
 import com.intellij.openapi.vcs.actions.VcsContextFactory;
 import com.intellij.openapi.vcs.changes.*;
 import com.intellij.openapi.vcs.history.VcsRevisionNumber;
@@ -63,13 +58,13 @@ public class CvsChangeProvider implements ChangeProvider {

  private final CvsVcs2 myVcs;
  private final CvsEntriesManager myEntriesManager;
-  private final ProjectFileIndex myFileIndex;
+  private final ProjectLevelVcsManager myVcsManager;
  private final ChangeListManager myChangeListManager;

  public CvsChangeProvider(final CvsVcs2 vcs, CvsEntriesManager entriesManager) {
    myVcs = vcs;
    myEntriesManager = entriesManager;
-    myFileIndex = ProjectRootManager.getInstance(vcs.getProject()).getFileIndex();
+    myVcsManager = ProjectLevelVcsManager.getInstance(vcs.getProject());
    myChangeListManager = ChangeListManager.getInstance(vcs.getProject());
  }

@@ -169,7 +164,7 @@ public class CvsChangeProvider implements ChangeProvider {
        for (VirtualFile file : children) {
          progress.checkCanceled();
          if (file.isDirectory()) {
-            final boolean isIgnored = myFileIndex.isExcluded(file);
+            final boolean isIgnored = myVcsManager.isIgnoredByVcs(file);
            if (!isIgnored) {
              processEntriesIn(file, scope, builder, true, progress);
            }
@@ -284,7 +279,7 @@ public class CvsChangeProvider implements ChangeProvider {

  private void checkSwitchedDir(final VirtualFile dir, final ChangelistBuilder builder, final VcsDirtyScope scope) {
    final VirtualFile parentDir = dir.getParent();
-    if (parentDir == null || !myFileIndex.isInContent(parentDir)) {
+    if (parentDir == null || !myVcsManager.isFileInContent(parentDir)) {
      return;
    }
    final CvsInfo info = myEntriesManager.getCvsInfoFor(dir);
@@ -317,7 +312,7 @@ public class CvsChangeProvider implements ChangeProvider {

  private void checkSwitchedFile(final FilePath filePath, final ChangelistBuilder builder, final VirtualFile dir, final Entry entry) {
    // if content root itself is switched, ignore
-    if (!myFileIndex.isInContent(dir)) {
+    if (!myVcsManager.isFileInContent(dir)) {
      return;
    }
    final String dirTag = myEntriesManager.getCvsInfoFor(dir).getStickyTag();
@@ -30,9 +30,8 @@ import com.intellij.openapi.fileChooser.FileElement;
 import com.intellij.openapi.fileChooser.FileSystemTree;
 import com.intellij.openapi.fileTypes.FileTypeManager;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ProjectFileIndex;
-import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.util.IconLoader;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -150,12 +149,11 @@ public class ImportTree extends NodeRenderer {
    if (myProject == null) {
      return;
    }
-    final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
-    if (!fileIndex.isExcluded(selectedFile)) {
+    if (!isIgnoredByVcs(selectedFile)) {
      return;
    }
    final VirtualFile parent = selectedFile.getParent();
-    if (parent != null && fileIndex.isExcluded(parent)) {
+    if (parent != null && isIgnoredByVcs(parent)) {
      return;
    }
    for (final VirtualFile excludedFile : myExcludedFiles) {
@@ -182,12 +180,11 @@ public class ImportTree extends NodeRenderer {
      if (myProject == null) {
        continue;
      }
-      final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
-      if (!fileIndex.isExcluded(selectedFile)) {
+      if (!isIgnoredByVcs(selectedFile)) {
        continue;
      }
      final VirtualFile parent = selectedFile.getParent();
-      if (parent == null || fileIndex.isExcluded(parent) || myExcludedFiles.contains(parent)) {
+      if (parent == null || isIgnoredByVcs(parent) || myExcludedFiles.contains(parent)) {
        continue;
      }
      if (!myIncludedFiles.contains(selectedFile)) {
@@ -211,7 +208,7 @@ public class ImportTree extends NodeRenderer {
        return true;
      }
    }
-    if (myProject == null || !ProjectRootManager.getInstance(myProject).getFileIndex().isExcluded(file)) {
+    if (myProject == null || !isIgnoredByVcs(file)) {
      return false;
    }
    for (VirtualFile includedFile : myIncludedFiles) {
@@ -242,7 +239,7 @@ public class ImportTree extends NodeRenderer {
        if (FileTypeManager.getInstance().isFileIgnored(abstractFileObject.getName())) return true;
        if (myProject != null && !includedFiles.contains(file)) {
          final VirtualFile vFile = LocalFileSystem.getInstance().findFileByIoFile(file);
-          if (vFile != null && ProjectRootManager.getInstance(myProject).getFileIndex().isExcluded(vFile)) {
+          if (vFile != null && isIgnoredByVcs(vFile)) {
            return true;
          }
        }
@@ -257,4 +254,8 @@ public class ImportTree extends NodeRenderer {
      }
    };
  }
+
+  private boolean isIgnoredByVcs(VirtualFile vFile) {
+    return myProject != null && ProjectLevelVcsManager.getInstance(myProject).isIgnoredByVcs(vFile);
+  }
 }
@@ -23,10 +23,10 @@ import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.DumbAwareAction;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.FileIndexFacade;
 import com.intellij.openapi.ui.Splitter;
 import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.Ref;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vcs.VcsDataKeys;
 import com.intellij.openapi.vcs.VcsException;
 import com.intellij.openapi.vcs.changes.ChangeListManager;
@@ -54,7 +54,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.github.api.GithubApiUtil;
 import org.jetbrains.plugins.github.api.GithubRepo;
 import org.jetbrains.plugins.github.api.GithubUserDetailed;
-import org.jetbrains.plugins.github.exceptions.GithubOperationCanceledException;
 import org.jetbrains.plugins.github.ui.GithubShareDialog;
 import org.jetbrains.plugins.github.util.*;

@@ -351,11 +350,11 @@ public class GithubShareAction extends DumbAwareAction {
  @NotNull
  private static Collection<VirtualFile> filterOutIgnored(@NotNull Project project, @NotNull Collection<VirtualFile> files) {
    final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
-    final FileIndexFacade fileIndex = FileIndexFacade.getInstance(project);
+    final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
    return ContainerUtil.filter(files, new Condition<VirtualFile>() {
      @Override
      public boolean value(VirtualFile file) {
-        return !changeListManager.isIgnoredFile(file) && !fileIndex.isExcludedFile(file);
+        return !changeListManager.isIgnoredFile(file) && !vcsManager.isIgnoredByVcs(file);
      }
    });
  }
@@ -15,12 +15,11 @@
 */
 package org.jetbrains.idea.svn;

-import com.intellij.lifecycle.PeriodicalTasksCloser;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.progress.ProgressIndicator;
-import com.intellij.openapi.roots.FileIndexFacade;
 import com.intellij.openapi.util.Computable;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vcs.changes.ChangeListManager;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
@@ -34,14 +33,14 @@ import org.tmatesoft.svn.core.wc.ISVNStatusFileProvider;
 public class StatusWalkerPartner {
  private final SvnVcs myVcs;
  private final ChangeListManager myClManager;
-  private final FileIndexFacade myExcludedFileIndex;
+  private final ProjectLevelVcsManager myVcsManager;
  private final ProgressIndicator myIndicator;
  private ISVNStatusFileProvider myFileProvider;

  public StatusWalkerPartner(final SvnVcs vcs, final ProgressIndicator pi) {
    myVcs = vcs;
    myClManager = ChangeListManager.getInstance(myVcs.getProject());
-    myExcludedFileIndex = PeriodicalTasksCloser.getInstance().safeGetService(myVcs.getProject(), FileIndexFacade.class);
+    myVcsManager = ProjectLevelVcsManager.getInstance(myVcs.getProject());
    myIndicator = pi;
  }

@@ -75,12 +74,12 @@ public class StatusWalkerPartner {
    }
  }

-  public boolean isExcluded(final VirtualFile vFile) {
+  public boolean isIgnoredByVcs(final VirtualFile vFile) {
    return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
      @Override
      public Boolean compute() {
        if (myVcs.getProject().isDisposed()) throw new ProcessCanceledException();
-        return myExcludedFileIndex.isExcludedFile(vFile);
+        return myVcsManager.isIgnoredByVcs(vFile);
      }
    });
  }
@@ -103,7 +103,7 @@ public class SvnRecursiveStatusWalker {
    if (e.contains(SVNErrorCode.WC_NOT_DIRECTORY) || e.contains(SVNErrorCode.WC_NOT_FILE)) {
      final VirtualFile virtualFile = path.getVirtualFile();
      if (virtualFile != null) {
-        if (! myPartner.isExcluded(virtualFile)) {
+        if (! myPartner.isIgnoredByVcs(virtualFile)) {
          // self is unversioned
          myReceiver.processUnversioned(virtualFile);

@@ -278,7 +278,7 @@ public class SvnRecursiveStatusWalker {
          @Override
          public Boolean compute() {
            if (myProject.isDisposed()) return null;
-            return myPartner.isExcluded(vFile);
+            return myPartner.isIgnoredByVcs(vFile);
          }
        });
        if (Boolean.TRUE.equals(excluded)) return;
@@ -15,11 +15,10 @@
 */
 package org.jetbrains.idea.svn.actions;

-import com.intellij.lifecycle.PeriodicalTasksCloser;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.FileIndexFacade;
 import com.intellij.openapi.util.Computable;
+import com.intellij.openapi.vcs.ProjectLevelVcsManager;
 import com.intellij.openapi.vcs.VcsException;
 import com.intellij.openapi.vcs.changes.ChangeListManager;
 import com.intellij.openapi.vfs.VfsUtilCore;
@@ -42,39 +41,36 @@ public class SvnExcludingIgnoredOperation {

  public static class Filter {
    private final Project myProject;
-    private final FileIndexFacade myIndex;
+    private final ProjectLevelVcsManager myVcsManager;
    private final ChangeListManager myClManager;

    public Filter(final Project project) {
      myProject = project;

      if (!project.isDefault()) {
-        myIndex = PeriodicalTasksCloser.getInstance().safeGetService(project, FileIndexFacade.class);
+        myVcsManager = ProjectLevelVcsManager.getInstance(project);
        myClManager = ChangeListManager.getInstance(project);
      }
      else {
-        myIndex = null;
+        myVcsManager = null;
        myClManager = null;
      }
    }

    public boolean accept(final VirtualFile file) {
      if (!myProject.isDefault()) {
-        if (isExcluded(file)) {
-          return false;
-        }
-        if (myClManager.isIgnoredFile(file)) {
+        if (isIgnoredByVcs(file) || myClManager.isIgnoredFile(file)) {
          return false;
        }
      }
      return true;
    }

-    private boolean isExcluded(final VirtualFile file) {
+    private boolean isIgnoredByVcs(final VirtualFile file) {
      return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
        @Override
        public Boolean compute() {
-          return myIndex.isExcludedFile(file);
+          return myVcsManager.isIgnoredByVcs(file);
        }
      });
    }