Java AnalysisScope类代码示例

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
@Override
public void runInspection(@NotNull final AnalysisScope scope,
                          @NotNull final InspectionManager manager,
                          @NotNull final GlobalInspectionContext globalContext,
                          @NotNull final ProblemDescriptionsProcessor problemDescriptionsProcessor) {
  globalContext.getRefManager().iterate(new RefJavaVisitor() {
    @Override public void visitClass(@NotNull RefClass refClass) {
      if (!globalContext.shouldCheck(refClass, RedundantSuppressInspectionBase.this)) return;
      CommonProblemDescriptor[] descriptors = checkElement(refClass, manager, globalContext.getProject());
      if (descriptors != null) {
        for (CommonProblemDescriptor descriptor : descriptors) {
          if (descriptor instanceof ProblemDescriptor) {
            final PsiElement psiElement = ((ProblemDescriptor)descriptor).getPsiElement();
            final PsiMember member = PsiTreeUtil.getParentOfType(psiElement, PsiMember.class);
            final RefElement refElement = globalContext.getRefManager().getReference(member);
            if (refElement != null) {
              problemDescriptionsProcessor.addProblemElement(refElement, descriptor);
              continue;
            }
          }
          problemDescriptionsProcessor.addProblemElement(refClass, descriptor);
        }
      }
    }
  });
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
private static PsiReferenceProcessor createReferenceProcessor(@NotNull final List<UsagesProcessor> processors,
                                                              final GlobalInspectionContext context) {
  return new PsiReferenceProcessor() {
    @Override
    public boolean execute(PsiReference reference) {
      AnalysisScope scope = context.getRefManager().getScope();
      if (scope != null && scope.contains(reference.getElement()) && reference.getElement().getLanguage() == StdLanguages.JAVA ||
          PsiTreeUtil.getParentOfType(reference.getElement(), PsiDocComment.class) != null) {
        return true;
      }

      synchronized (processors) {
        UsagesProcessor[] processorsArrayed = processors.toArray(new UsagesProcessor[processors.size()]);
        for (UsagesProcessor processor : processorsArrayed) {
          if (!processor.process(reference)) {
            processors.remove(processor);
          }
        }
      }

      return !processors.isEmpty();
    }
  };
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
private static boolean processValuesFlownTo(@NotNull final PsiExpression argument,
                                            @NotNull PsiElement scope,
                                            @NotNull PsiManager manager,
                                            @NotNull final Processor<PsiExpression> processor) {
  SliceAnalysisParams params = new SliceAnalysisParams();
  params.dataFlowToThis = true;
  params.scope = new AnalysisScope(new LocalSearchScope(scope), manager.getProject());

  SliceRootNode rootNode = new SliceRootNode(manager.getProject(), new DuplicateMap(), LanguageSlicing.getProvider(argument).createRootUsage(argument, params));

  Collection<? extends AbstractTreeNode> children = rootNode.getChildren().iterator().next().getChildren();
  for (AbstractTreeNode child : children) {
    SliceUsage usage = (SliceUsage)child.getValue();
    PsiElement element = usage.getElement();
    if (element instanceof PsiExpression && !processor.process((PsiExpression)element)) return false;
  }

  return !children.isEmpty();
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
@Override
public void actionPerformed(final AnActionEvent e) {
  final AnalysisScope scope = getScope();
  LOG.assertTrue(scope != null);
  final DependenciesBuilder builder;
  if (!myForward) {
    builder = new BackwardDependenciesBuilder(myProject, scope, myScopeOfInterest);
  } else {
    builder = new ForwardDependenciesBuilder(myProject, scope, myTransitiveBorder);
  }
  ProgressManager.getInstance().runProcessWithProgressAsynchronously(myProject, AnalysisScopeBundle.message("package.dependencies.progress.title"), new Runnable() {
    @Override
    public void run() {
      builder.analyze();
    }
  }, new Runnable() {
    @Override
    public void run() {
      myBuilders.add(builder);
      myDependencies.putAll(builder.getDependencies());
      putAllDependencies(builder);
      exclude(myExcluded);
      rebuild();
    }
  }, null, new PerformAnalysisInBackgroundOption(myProject));
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
private void doTest() throws Exception {
  configureByFile("/codeInsight/slice/backward/"+getTestName(false)+".java");
  Map<String, RangeMarker> sliceUsageName2Offset = SliceTestUtil.extractSliceOffsetsFromDocument(getEditor().getDocument());
  PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
  PsiElement element = new SliceHandler(true).getExpressionAtCaret(getEditor(), getFile());
  assertNotNull(element);
  SliceTestUtil.calcRealOffsets(element, sliceUsageName2Offset, myFlownOffsets);
  Collection<HighlightInfo> errors = highlightErrors();
  assertEmpty(errors);
  SliceAnalysisParams params = new SliceAnalysisParams();
  params.scope = new AnalysisScope(getProject());
  params.dataFlowToThis = true;

  SliceUsage usage = LanguageSlicing.getProvider(element).createRootUsage(element, params);
  SliceTestUtil.checkUsages(usage, myFlownOffsets);
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
protected void doTest(final boolean shouldSucceed) throws Exception {
  final String filePath = getTestFilePath();
  configureByFile(filePath);
  final PsiElement targetElement = TargetElementUtil.findTargetElement(getEditor(), TargetElementUtil.ELEMENT_NAME_ACCEPTED);
  assertTrue("<caret> is not on method name", targetElement instanceof PsiMember);
  final PsiMember psiMethod = (PsiMember)targetElement;

  try {
    MethodDuplicatesHandler.invokeOnScope(getProject(), psiMethod, new AnalysisScope(getFile()));
  }
  catch (RuntimeException e) {
    if (shouldSucceed) {
      fail("duplicates were not found");
    }
    return;
  }
  UIUtil.dispatchAllInvocationEvents();
  if (shouldSucceed) {
    checkResultByFile(filePath + ".after");
  }
  else {
    fail("duplicates found");
  }
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
public void testForwardSimple(){
  final DependenciesBuilder builder = new ForwardDependenciesBuilder(myProject, new AnalysisScope(myProject));
  builder.analyze();

  final Set<PsiFile> searchIn = new HashSet<PsiFile>();
  final PsiClass aClass = myJavaFacade.findClass("A", GlobalSearchScope.allScope(myProject));
  searchIn.add(aClass.getContainingFile());
  final Set<PsiFile> searchFor = new HashSet<PsiFile>();
  final PsiClass bClass = myJavaFacade.findClass("B", GlobalSearchScope.allScope(myProject));
  searchFor.add(bClass.getContainingFile());

  final UsageInfo[] usagesInfos = FindDependencyUtil.findDependencies(builder, searchIn, searchFor);
  final UsageInfo2UsageAdapter[] usages = UsageInfo2UsageAdapter.convert(usagesInfos);
  final String [] psiUsages = new String [usagesInfos.length];
  for (int i = 0; i < usagesInfos.length; i++) {
    psiUsages[i] = toString(usages[i]);
  }
  checkResult(new String []{"(2: 3) B myB = new B();", "(2: 15) B myB = new B();", "(4: 9) myB.bb();"}, psiUsages);
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
public void testForwardJdkClasses(){
  final DependenciesBuilder builder = new ForwardDependenciesBuilder(myProject, new AnalysisScope(myProject));
  builder.analyze();

  final Set<PsiFile> searchIn = new HashSet<PsiFile>();
  final PsiClass aClass = myJavaFacade.findClass("A", GlobalSearchScope.allScope(myProject));
  searchIn.add(aClass.getContainingFile());

  final Set<PsiFile> searchFor = new HashSet<PsiFile>();
  final PsiClass stringClass = myJavaFacade.findClass("java.lang.String", GlobalSearchScope.allScope(myProject));
  searchFor.add((PsiFile)stringClass.getContainingFile().getNavigationElement());

  final UsageInfo[] usagesInfos = FindDependencyUtil.findDependencies(builder, searchIn, searchFor);
  final UsageInfo2UsageAdapter[] usages = UsageInfo2UsageAdapter.convert(usagesInfos);
  final String [] psiUsages = new String [usagesInfos.length];
  for (int i = 0; i < usagesInfos.length; i++) {
    psiUsages[i] = toString(usages[i]);
  }
  checkResult(new String []{"(2: 3) String myName;"}, psiUsages);
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
protected void launchInspections(@NotNull final AnalysisScope scope) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  PsiDocumentManager.getInstance(myProject).commitAllDocuments();

  LOG.info("Code inspection started");
  ProgressManager.getInstance().run(new Task.Backgroundable(getProject(), InspectionsBundle.message("inspection.progress.title"), true,
                                                            createOption()) {
    @Override
    public void run(@NotNull ProgressIndicator indicator) {
      performInspectionsWithProgress(scope, false, false);
    }

    @Override
    public void onSuccess() {
      notifyInspectionsFinished();
    }
  });
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
private void perform(List<DependenciesBuilder> builders) {
  try {
    PerformanceWatcher.Snapshot snapshot = PerformanceWatcher.takeSnapshot();
    for (AnalysisScope scope : myScopes) {
      builders.add(createDependenciesBuilder(scope));
    }
    for (DependenciesBuilder builder : builders) {
      builder.analyze();
    }
    snapshot.logResponsivenessSinceCreation("Dependency analysis");
  }
  catch (IndexNotReadyException e) {
    DumbService.getInstance(myProject).showDumbModeNotification("Analyze dependencies is not available until indices are ready");
    throw new ProcessCanceledException();
  }
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
@NotNull
private static Factory<UsageSearcher> rerunFactory(@NotNull final Project project, @NotNull final AnalysisScope scope) {
  return new Factory<UsageSearcher>() {
    @Override
    public UsageSearcher create() {
      return new UsageInfoSearcherAdapter() {
        @Override
        protected UsageInfo[] findUsages() {
          return AndroidInferNullityAnnotationAction.findUsages(project, scope, scope.getFileCount());
        }

        @Override
        public void generate(@NotNull Processor<Usage> processor) {
          processUsages(processor, project);
        }
      };
    }
  };
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
@Nullable
private AnalysisScope getScope() {
  final Set<PsiFile> selectedScope = getSelectedScope(myRightTree);
  Set<PsiFile> result = new HashSet<PsiFile>();
  ((PackageDependenciesNode)myLeftTree.getModel().getRoot()).fillFiles(result, !mySettings.UI_FLATTEN_PACKAGES);
  selectedScope.removeAll(result);
  if (selectedScope.isEmpty()) return null;
  List<VirtualFile> files = new ArrayList<VirtualFile>();
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
  for (PsiFile psiFile : selectedScope) {
    final VirtualFile file = psiFile.getVirtualFile();
    LOG.assertTrue(file != null);
    if (fileIndex.isInContent(file)) {
      files.add(file);
    }
  }
  if (!files.isEmpty()) {
    return new AnalysisScope(myProject, files);
  }
  return null;
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
@NotNull
@TestOnly
public static GlobalInspectionContextForTests createGlobalContextForTool(@NotNull AnalysisScope scope,
                                                                         @NotNull final Project project,
                                                                         @NotNull InspectionManagerEx inspectionManager,
                                                                         @NotNull final InspectionToolWrapper... toolWrappers) {
  final InspectionProfileImpl profile = InspectionProfileImpl.createSimple("test", project, toolWrappers);
  GlobalInspectionContextForTests context = new GlobalInspectionContextForTests(project, inspectionManager.getContentManager()) {
    @NotNull
    @Override
    protected List<Tools> getUsedTools() {
      return InspectionProfileImpl.initAndDo(new Computable<List<Tools>>() {
        @Override
        public List<Tools> compute() {
          for (InspectionToolWrapper tool : toolWrappers) {
            profile.enableTool(tool.getShortName(), project);
          }
          return profile.getAllEnabledInspectionTools(project);
        }
      });
    }
  };
  context.setCurrentScope(scope);

  return context;
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
@NotNull
public static InspectionResultsView showOfflineView(@NotNull Project project,
                                                    @NotNull Map<String, Map<String, Set<OfflineProblemDescriptor>>> resMap,
                                                    @NotNull InspectionProfile inspectionProfile,
                                                    @NotNull String title) {
  final AnalysisScope scope = new AnalysisScope(project);
  final InspectionManagerEx managerEx = (InspectionManagerEx)InspectionManager.getInstance(project);
  final GlobalInspectionContextImpl context = managerEx.createNewGlobalContext(false);
  context.setExternalProfile(inspectionProfile);
  context.setCurrentScope(scope);
  context.initializeTools(new ArrayList<Tools>(), new ArrayList<Tools>(), new ArrayList<Tools>());
  final InspectionResultsView view = new InspectionResultsView(project, inspectionProfile, scope, context,
                                                               new OfflineInspectionRVContentProvider(resMap, project));
  ((RefManagerImpl)context.getRefManager()).startOfflineView();
  view.update();
  TreeUtil.selectFirstNode(view.getTree());
  context.addView(view, title);
  return view;
}
 

import com.intellij.analysis.AnalysisScope; //导入依赖的package包/类
private static boolean processValuesFlownTo(@NotNull final PsiExpression argument,
                                            @NotNull PsiElement scope,
                                            @NotNull PsiManager manager,
                                            @NotNull final Processor<PsiExpression> processor) {
  SliceAnalysisParams params = new SliceAnalysisParams();
  params.dataFlowToThis = true;
  params.scope = new AnalysisScope(new LocalSearchScope(scope), manager.getProject());

  SliceRootNode rootNode = new SliceRootNode(manager.getProject(), new DuplicateMap(),
                                             LanguageSlicing.getProvider(argument).createRootUsage(argument, params));

  @SuppressWarnings("unchecked")
  Collection<? extends AbstractTreeNode> children = rootNode.getChildren().iterator().next().getChildren();
  for (AbstractTreeNode child : children) {
    SliceUsage usage = (SliceUsage)child.getValue();
    if (usage == null) {
      continue;
    }
    PsiElement element = usage.getElement();
    if (element instanceof PsiExpression && !processor.process((PsiExpression)element)) return false;
  }

  return !children.isEmpty();
}