Examples with LocalSearchScope com.intellij.psi.search.LocalSearchScope used on opensource projects

Example 56 with LocalSearchScope

use of com.intellij.psi.search.LocalSearchScope in project intellij-plugins by JetBrains.

the class DartServerFindUsagesHandler method processElementUsages.

@Override
public boolean processElementUsages(@NotNull final PsiElement elementToSearch, @NotNull final Processor<UsageInfo> processor, @NotNull final FindUsagesOptions options) {
    final SearchScope scope = options.searchScope;
    final Project project = ReadAction.compute(this::getProject);
    final DartAnalysisServerService service = DartAnalysisServerService.getInstance(project);
    final ReadActionConsumer<SearchResult> searchResultProcessor = new ReadActionConsumer<SearchResult>() {

        @Override
        public void consumeInReadAction(SearchResult result) {
            if (result.getKind().equals(SearchResultKind.DECLARATION))
                return;
            final Location location = result.getLocation();
            final VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(FileUtil.toSystemIndependentName(location.getFile()));
            if (vFile == null)
                return;
            if (!scope.contains(vFile))
                return;
            final PsiFile psiFile = elementToSearch.getManager().findFile(vFile);
            if (psiFile == null)
                return;
            final int offset = service.getConvertedOffset(vFile, location.getOffset());
            final int length = service.getConvertedOffset(vFile, location.getOffset() + location.getLength()) - offset;
            final TextRange range = TextRange.create(offset, offset + length);
            final boolean potentialUsage = result.isPotential();
            final PsiElement usageElement = getUsagePsiElement(psiFile, range);
            final UsageInfo usageInfo = usageElement == null ? null : getUsageInfo(usageElement, range, potentialUsage);
            if (usageInfo != null && usageInfo.getElement() != null && (!(scope instanceof LocalSearchScope) || PsiSearchScopeUtil.isInScope((LocalSearchScope) scope, usageInfo.getElement()))) {
                processor.process(usageInfo);
            }
        }
    };
    final VirtualFile file = ReadAction.compute(() -> elementToSearch.getContainingFile().getVirtualFile());
    final int offset = elementToSearch.getTextRange().getStartOffset();
    service.search_findElementReferences(file, offset, searchResultProcessor);
    return true;
}

Example 57 with LocalSearchScope

use of com.intellij.psi.search.LocalSearchScope in project android by JetBrains.

the class AndroidLintGlobalInspectionContext method performPreRunActivities.

@Override
public void performPreRunActivities(@NotNull List<Tools> globalTools, @NotNull List<Tools> localTools, @NotNull final GlobalInspectionContext context) {
    final Project project = context.getProject();
    // Running a single inspection that's not lint? If so don't run lint
    if (localTools.isEmpty() && globalTools.size() == 1) {
        Tools tool = globalTools.get(0);
        if (!tool.getShortName().startsWith(LINT_INSPECTION_PREFIX)) {
            return;
        }
    }
    if (!ProjectFacetManager.getInstance(project).hasFacets(AndroidFacet.ID)) {
        return;
    }
    List<Issue> issues = AndroidLintExternalAnnotator.getIssuesFromInspections(project, null);
    if (issues.size() == 0) {
        return;
    }
    // If running a single check by name, turn it on if it's off by default.
    if (localTools.isEmpty() && globalTools.size() == 1) {
        Tools tool = globalTools.get(0);
        String id = tool.getShortName().substring(LINT_INSPECTION_PREFIX.length());
        Issue issue = new LintIdeIssueRegistry().getIssue(id);
        if (issue != null && !issue.isEnabledByDefault()) {
            issues = Collections.singletonList(issue);
            issue.setEnabledByDefault(true);
            // And turn it back off again in cleanup
            myEnabledIssue = issue;
        }
    }
    final Map<Issue, Map<File, List<ProblemData>>> problemMap = new HashMap<>();
    AnalysisScope scope = context.getRefManager().getScope();
    if (scope == null) {
        scope = AndroidLintLintBaselineInspection.ourRerunScope;
        if (scope == null) {
            return;
        }
    }
    final LintIdeClient client = LintIdeClient.forBatch(project, problemMap, scope, issues);
    final LintDriver lint = new LintDriver(new LintIdeIssueRegistry(), client);
    final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
    if (indicator != null) {
        ProgressWrapper.unwrap(indicator).setText("Running Android Lint");
    }
    EnumSet<Scope> lintScope;
    //noinspection ConstantConditions
    if (!LintIdeProject.SUPPORT_CLASS_FILES) {
        lintScope = EnumSet.copyOf(Scope.ALL);
        // Can't run class file based checks
        lintScope.remove(Scope.CLASS_FILE);
        lintScope.remove(Scope.ALL_CLASS_FILES);
        lintScope.remove(Scope.JAVA_LIBRARIES);
    } else {
        lintScope = Scope.ALL;
    }
    List<VirtualFile> files = null;
    final List<Module> modules = Lists.newArrayList();
    int scopeType = scope.getScopeType();
    switch(scopeType) {
        case AnalysisScope.MODULE:
            {
                SearchScope searchScope = ReadAction.compute(scope::toSearchScope);
                if (searchScope instanceof ModuleWithDependenciesScope) {
                    ModuleWithDependenciesScope s = (ModuleWithDependenciesScope) searchScope;
                    if (!s.isSearchInLibraries()) {
                        modules.add(s.getModule());
                    }
                }
                break;
            }
        case AnalysisScope.FILE:
        case AnalysisScope.VIRTUAL_FILES:
        case AnalysisScope.UNCOMMITTED_FILES:
            {
                files = Lists.newArrayList();
                SearchScope searchScope = scope.toSearchScope();
                if (searchScope instanceof LocalSearchScope) {
                    final LocalSearchScope localSearchScope = (LocalSearchScope) searchScope;
                    final PsiElement[] elements = localSearchScope.getScope();
                    final List<VirtualFile> finalFiles = files;
                    ApplicationManager.getApplication().runReadAction(() -> {
                        for (PsiElement element : elements) {
                            if (element instanceof PsiFile) {
                                // should be the case since scope type is FILE
                                Module module = ModuleUtilCore.findModuleForPsiElement(element);
                                if (module != null && !modules.contains(module)) {
                                    modules.add(module);
                                }
                                VirtualFile virtualFile = ((PsiFile) element).getVirtualFile();
                                if (virtualFile != null) {
                                    if (virtualFile instanceof StringsVirtualFile) {
                                        StringsVirtualFile f = (StringsVirtualFile) virtualFile;
                                        if (!modules.contains(f.getFacet().getModule())) {
                                            modules.add(f.getFacet().getModule());
                                        }
                                    } else {
                                        finalFiles.add(virtualFile);
                                    }
                                }
                            }
                        }
                    });
                } else {
                    final List<VirtualFile> finalList = files;
                    scope.accept(new PsiElementVisitor() {

                        @Override
                        public void visitFile(PsiFile file) {
                            VirtualFile virtualFile = file.getVirtualFile();
                            if (virtualFile != null) {
                                finalList.add(virtualFile);
                            }
                        }
                    });
                }
                if (files.isEmpty()) {
                    files = null;
                } else {
                    // Lint will compute it lazily based on actual files in the request
                    lintScope = null;
                }
                break;
            }
        case AnalysisScope.PROJECT:
            {
                modules.addAll(Arrays.asList(ModuleManager.getInstance(project).getModules()));
                break;
            }
        case AnalysisScope.CUSTOM:
        case AnalysisScope.MODULES:
        case AnalysisScope.DIRECTORY:
            {
                // Handled by the getNarrowedComplementaryScope case below
                break;
            }
        case AnalysisScope.INVALID:
            break;
        default:
            Logger.getInstance(this.getClass()).warn("Unexpected inspection scope " + scope + ", " + scopeType);
    }
    if (modules.isEmpty()) {
        for (Module module : ModuleManager.getInstance(project).getModules()) {
            if (scope.containsModule(module)) {
                modules.add(module);
            }
        }
        if (modules.isEmpty() && files != null) {
            for (VirtualFile file : files) {
                Module module = ModuleUtilCore.findModuleForFile(file, project);
                if (module != null && !modules.contains(module)) {
                    modules.add(module);
                }
            }
        }
        if (modules.isEmpty()) {
            AnalysisScope narrowed = scope.getNarrowedComplementaryScope(project);
            for (Module module : ModuleManager.getInstance(project).getModules()) {
                if (narrowed.containsModule(module)) {
                    modules.add(module);
                }
            }
        }
    }
    LintRequest request = new LintIdeRequest(client, project, files, modules, false);
    request.setScope(lintScope);
    // Baseline analysis?
    myBaseline = null;
    for (Module module : modules) {
        AndroidModuleModel model = AndroidModuleModel.get(module);
        if (model != null) {
            GradleVersion version = model.getModelVersion();
            if (version != null && version.isAtLeast(2, 3, 0, "beta", 2, true)) {
                LintOptions options = model.getAndroidProject().getLintOptions();
                try {
                    File baselineFile = options.getBaselineFile();
                    if (baselineFile != null && !AndroidLintLintBaselineInspection.ourSkipBaselineNextRun) {
                        if (!baselineFile.isAbsolute()) {
                            String path = module.getProject().getBasePath();
                            if (path != null) {
                                baselineFile = new File(FileUtil.toSystemDependentName(path), baselineFile.getPath());
                            }
                        }
                        myBaseline = new LintBaseline(client, baselineFile);
                        lint.setBaseline(myBaseline);
                        if (!baselineFile.isFile()) {
                            myBaseline.setWriteOnClose(true);
                        } else if (AndroidLintLintBaselineInspection.ourUpdateBaselineNextRun) {
                            myBaseline.setRemoveFixed(true);
                            myBaseline.setWriteOnClose(true);
                        }
                    }
                } catch (Throwable unsupported) {
                // During 2.3 development some builds may have this method, others may not
                }
            }
            break;
        }
    }
    lint.analyze(request);
    AndroidLintLintBaselineInspection.clearNextRunState();
    myResults = problemMap;
}

Example 58 with LocalSearchScope

use of com.intellij.psi.search.LocalSearchScope in project android by JetBrains.

the class ResourceTypeInspection method processValuesFlownTo.

@NotNull
private static InspectionResult processValuesFlownTo(@NotNull final PsiExpression argument, @NotNull PsiElement scope, @NotNull PsiManager manager, @NotNull final Function<PsiExpression, InspectionResult> processor) {
    SliceAnalysisParams params = new SliceAnalysisParams();
    params.dataFlowToThis = true;
    params.scope = new AnalysisScope(new LocalSearchScope(scope), manager.getProject());
    SliceLanguageSupportProvider languageSlicing = LanguageSlicing.getProvider(argument);
    assert languageSlicing != null;
    SliceRootNode rootNode = new SliceRootNode(manager.getProject(), new DuplicateMap(), languageSlicing.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) {
            // If we report an error, use the current expression being evaluated. This will mark the error in the argument as opposed to using
            // the original field or variable declaration.
            InspectionResult result = processor.fun((PsiExpression) element).useErrorNode(argument);
            if (result.isInvalid()) {
                return result;
            }
        }
    }
    return !children.isEmpty() ? InspectionResult.valid() : InspectionResult.uncertain();
}

Example 59 with LocalSearchScope

use of com.intellij.psi.search.LocalSearchScope in project kotlin by JetBrains.

the class MoveDeclarationsOutHelper method move.

public static PsiElement[] move(@NotNull PsiElement container, @NotNull PsiElement[] statements, boolean generateDefaultInitializers) {
    if (statements.length == 0) {
        return statements;
    }
    Project project = container.getProject();
    List<PsiElement> resultStatements = new ArrayList<PsiElement>();
    List<KtProperty> propertiesDeclarations = new ArrayList<KtProperty>();
    // Dummy element to add new declarations at the beginning
    KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(project);
    PsiElement dummyFirstStatement = container.addBefore(psiFactory.createExpression("dummyStatement"), statements[0]);
    try {
        SearchScope scope = new LocalSearchScope(container);
        int lastStatementOffset = statements[statements.length - 1].getTextRange().getEndOffset();
        for (PsiElement statement : statements) {
            if (needToDeclareOut(statement, lastStatementOffset, scope)) {
                if (statement instanceof KtProperty && ((KtProperty) statement).getInitializer() != null) {
                    KtProperty property = (KtProperty) statement;
                    KtProperty declaration = createVariableDeclaration(property, generateDefaultInitializers);
                    declaration = (KtProperty) container.addBefore(declaration, dummyFirstStatement);
                    propertiesDeclarations.add(declaration);
                    container.addAfter(psiFactory.createNewLine(), declaration);
                    KtBinaryExpression assignment = createVariableAssignment(property);
                    resultStatements.add(property.replace(assignment));
                } else {
                    PsiElement newStatement = container.addBefore(statement, dummyFirstStatement);
                    container.addAfter(psiFactory.createNewLine(), newStatement);
                    container.deleteChildRange(statement, statement);
                }
            } else {
                resultStatements.add(statement);
            }
        }
    } finally {
        dummyFirstStatement.delete();
    }
    ShortenReferences.DEFAULT.process(propertiesDeclarations);
    return PsiUtilCore.toPsiElementArray(resultStatements);
}

Example 60 with LocalSearchScope

use of com.intellij.psi.search.LocalSearchScope in project smali by JesusFreke.

the class HighlightLocalClassUsagesTest method testHighlightLocalClassUsage.

public void testHighlightLocalClassUsage() throws Exception {
    String fileText = "" + ".class public Lbl<ref>arg; .super Ljava/lang/Object;\n" + ".method public doSomething()V\n" + "  .registers 1\n" + "  new-instance v0, Lbl<ref>arg;\n" + "  invoke-direct {v0}, Lblah;-><init>()V\n" + "  return-void\n" + ".end method";
    PsiFile file = createFile("blarg.smali", fileText.replace("<ref>", ""));
    PsiElement target;
    int refIndex = fileText.indexOf("<ref>");
    PsiReference reference = file.findReferenceAt(refIndex);
    if (reference != null) {
        target = reference.resolve();
    } else {
        target = TargetElementUtilBase.getInstance().getNamedElement(file.findElementAt(refIndex), 0);
    }
    final LocalSearchScope scope = new LocalSearchScope(file);
    List<PsiReference> refs = Lists.newArrayList(ReferencesSearch.search(target, scope).findAll());
    Assert.assertEquals(2, refs.size());
    Assert.assertEquals(file.findElementAt(refIndex).getTextOffset(), refs.get(0).getElement().getTextOffset());
    Assert.assertEquals(file.findElementAt(fileText.replaceFirst("<ref>", "").indexOf("<ref>")).getTextOffset(), refs.get(1).getElement().getTextOffset());
}