java/java-impl/src/com/intellij/analysis/JavaAnalysisScope.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * User: anna
  19  * Date: 14-Jan-2008
  20  */
  21 package com.intellij.analysis;
  22
  23 import com.intellij.openapi.application.ApplicationManager;
  24 import com.intellij.openapi.module.Module;
  25 import com.intellij.openapi.project.Project;
  26 import com.intellij.openapi.roots.ProjectFileIndex;
  27 import com.intellij.openapi.roots.ProjectRootManager;
  28 import com.intellij.openapi.vfs.VirtualFile;
  29 import com.intellij.psi.*;
  30 import com.intellij.psi.search.GlobalSearchScope;
  31 import com.intellij.psi.search.SearchScope;
  32 import com.intellij.psi.search.PackageScope;
  33 import org.jetbrains.annotations.NotNull;
  34
  35 import java.util.Arrays;
  36 import java.util.HashSet;
  37 import java.util.Set;
  38
  39 public class JavaAnalysisScope extends AnalysisScope {
  40   public static final int PACKAGE = 5;
  41
  42   public JavaAnalysisScope(PsiPackage pack, Module module) {
  43     super(pack.getProject());
  44     myModule = module;
  45     myElement = pack;
  46     myType = PACKAGE;
  47   }
  48
  49   public JavaAnalysisScope(final PsiJavaFile psiFile) {
  50     super(psiFile);
  51   }
  52
  53   public AnalysisScope[] getNarrowedComplementaryScope(Project defaultProject) {
  54     final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(defaultProject).getFileIndex();
  55     final HashSet<Module> modules = new HashSet<Module>();
  56     if (myType == FILE) {
  57       if (myElement instanceof PsiJavaFile && !JspPsiUtil.isInJspFile(myElement)) {
  58         PsiJavaFile psiJavaFile = (PsiJavaFile)myElement;
  59         final PsiClass[] classes = psiJavaFile.getClasses();
  60         boolean onlyPackLocalClasses = true;
  61         for (final PsiClass aClass : classes) {
  62           if (aClass.hasModifierProperty(PsiModifier.PUBLIC)) {
  63             onlyPackLocalClasses = false;
  64           }
  65         }
  66         if (onlyPackLocalClasses) {
  67           final PsiDirectory psiDirectory = psiJavaFile.getContainingDirectory();
  68           if (psiDirectory != null) {
  69             return new AnalysisScope[]{new JavaAnalysisScope(JavaDirectoryService.getInstance().getPackage(psiDirectory), null)};
  70           }
  71         }
  72       }
  73     }
  74     else if (myType == PACKAGE) {
  75       final PsiDirectory[] directories = ((PsiPackage)myElement).getDirectories();
  76       for (PsiDirectory directory : directories) {
  77         modules.addAll(getAllInterestingModules(fileIndex, directory.getVirtualFile()));
  78       }
  79       return collectScopes(defaultProject, modules);
  80     }
  81     return super.getNarrowedComplementaryScope(defaultProject);
  82   }
  83
  84
  85
  86   public String getShortenName() {
  87     if (myType == PACKAGE)
  88        return AnalysisScopeBundle.message("scope.package", ((PsiPackage)myElement).getQualifiedName());
  89     return super.getShortenName();
  90   }
  91
  92   public String getDisplayName() {
  93     if (myType == PACKAGE) {
  94       return AnalysisScopeBundle.message("scope.package", ((PsiPackage)myElement).getQualifiedName());
  95     }
  96     return super.getDisplayName();
  97   }
  98
  99   protected void initFilesSet() {
 100     if (myType == PACKAGE) {
 101       myFilesSet = new HashSet<VirtualFile>();
 102       accept(createFileSearcher());
 103       return;
 104     }
 105     super.initFilesSet();
 106   }
 107
 108   protected void accept(final PsiElementVisitor visitor, final boolean needReadAction) {
 109     if (myElement instanceof PsiPackage) {
 110       final PsiPackage pack = (PsiPackage)myElement;
 111       final Set<PsiDirectory> dirs = new HashSet<PsiDirectory>();
 112       ApplicationManager.getApplication().runReadAction(new Runnable() {
 113         public void run() {
 114           dirs.addAll(Arrays.asList(pack.getDirectories(GlobalSearchScope.projectScope(myElement.getProject()))));
 115         }
 116       });
 117       for (PsiDirectory dir : dirs) {
 118         accept(dir, visitor, needReadAction);
 119       }
 120     } else {
 121       super.accept(visitor, needReadAction);
 122     }
 123   }
 124
 125   @NotNull
 126   @Override
 127   public SearchScope toSearchScope() {
 128     if (myType == PACKAGE) {
 129       return new PackageScope((PsiPackage)myElement, true, true);
 130     }
 131     return super.toSearchScope();
 132   }
 133 }