Examples with OccurrencesAnalyzer com.python.pydev.analysis.OccurrencesAnalyzer used on opensource projects

Example 1 with OccurrencesAnalyzer

use of com.python.pydev.analysis.OccurrencesAnalyzer in project Pydev by fabioz.

the class AnalysisBuilderRunnable method doAnalysis.

@Override
protected void doAnalysis() {
    if (!nature.startRequests()) {
        return;
    }
    try {
        if (DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
            org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "doAnalysis() - " + moduleName + " " + this.getAnalysisCauseStr());
        }
        // if the resource is not open, there's not much we can do...
        final IResource r = resource;
        if (r == null) {
            org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Finished analysis -- resource null -- " + moduleName);
            return;
        }
        if (!r.getProject().isOpen()) {
            org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Finished analysis -- project closed -- " + moduleName);
            return;
        }
        AnalysisRunner runner = new AnalysisRunner();
        checkStop();
        IAnalysisPreferences analysisPreferences = new AnalysisPreferences(r);
        boolean makeAnalysis = // just get problems in resources that are in the pythonpath
        runner.canDoAnalysis(document) && PyDevBuilderVisitor.isInPythonPath(r) && analysisPreferences.makeCodeAnalysis();
        boolean anotherVisitorRequiresAnalysis = false;
        for (IExternalCodeAnalysisVisitor visitor : allVisitors) {
            anotherVisitorRequiresAnalysis |= visitor.getRequiresAnalysis();
        }
        if (!makeAnalysis) {
            // let's see if we should do code analysis
            if (DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
                org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Skipping: !makeAnalysis -- " + moduleName);
            }
            if (!anotherVisitorRequiresAnalysis) {
                AnalysisRunner.deleteMarkers(r);
                return;
            } else {
                // Only delete pydev markers (others will be deleted by the respective visitors later on).
                boolean onlyPydevAnalysisMarkers = true;
                AnalysisRunner.deleteMarkers(r, onlyPydevAnalysisMarkers);
            }
        }
        if (makeAnalysis && onlyRecreateCtxInsensitiveInfo) {
            if (DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
                org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Skipping: !forceAnalysis && analysisCause == ANALYSIS_CAUSE_BUILDER && " + "PyDevBuilderPrefPage.getAnalyzeOnlyActiveEditor() -- " + moduleName);
            }
            return;
        }
        if (nature == null) {
            Log.log("Finished analysis: null nature -- " + moduleName);
            return;
        }
        AbstractAdditionalTokensInfo info = AdditionalProjectInterpreterInfo.getAdditionalInfoForProject(nature);
        if (info == null) {
            Log.log("Unable to get additional info for: " + r + " -- " + moduleName);
            return;
        }
        if (makeAnalysis && DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
            org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "makeAnalysis:" + makeAnalysis + " " + "analysisCause: " + getAnalysisCauseStr() + " -- " + moduleName);
        }
        checkStop();
        if (isHierarchicallyDerived(r)) {
            if (DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
                org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Resource marked as derived not analyzed: " + r + " -- " + moduleName);
            }
            // might be already there)
            if (r != null) {
                AnalysisRunner.deleteMarkers(r);
            }
            return;
        }
        // Maybe we can improve that when https://github.com/PyCQA/pylint/pull/1189 is done.
        if (!DocumentChanged.hasDocumentChanged(resource, document)) {
            for (IExternalCodeAnalysisVisitor visitor : allVisitors) {
                visitor.startVisit();
            }
        } else {
            for (IExternalCodeAnalysisVisitor visitor : allVisitors) {
                visitor.deleteMarkers();
            }
            if (!makeAnalysis) {
                return;
            }
        }
        List<MarkerInfo> markersFromCodeAnalysis = null;
        if (makeAnalysis) {
            OccurrencesAnalyzer analyzer = new OccurrencesAnalyzer();
            checkStop();
            SourceModule module = (SourceModule) this.module.call(moduleRequest);
            IMessage[] messages = analyzer.analyzeDocument(nature, module, analysisPreferences, document, this.internalCancelMonitor, DefaultIndentPrefs.get(this.resource));
            checkStop();
            if (DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
                org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Adding markers for module: " + moduleName);
            // for (IMessage message : messages) {
            // Log.toLogFile(this, message.toString());
            // }
            }
            // last chance to stop...
            checkStop();
            // don't stop after setting to add / remove the markers
            if (r != null) {
                boolean analyzeOnlyActiveEditor = PyDevBuilderPreferences.getAnalyzeOnlyActiveEditor();
                if (forceAnalysis || !analyzeOnlyActiveEditor || (analyzeOnlyActiveEditor && (!PyDevBuilderPreferences.getRemoveErrorsWhenEditorIsClosed() || OpenEditors.isEditorOpenForResource(r)))) {
                    markersFromCodeAnalysis = runner.setMarkers(r, document, messages, this.internalCancelMonitor);
                } else {
                    if (DebugSettings.DEBUG_ANALYSIS_REQUESTS) {
                        org.python.pydev.shared_core.log.ToLogFile.toLogFile(this, "Skipped adding markers for module: " + moduleName + " (editor not opened).");
                    }
                }
            }
        }
        // if there are callbacks registered, call them if we still didn't return (mostly for tests)
        for (ICallback<Object, IResource> callback : analysisBuilderListeners) {
            try {
                callback.call(r);
            } catch (Exception e) {
                Log.log(e);
            }
        }
        checkStop();
        for (IExternalCodeAnalysisVisitor visitor : allVisitors) {
            visitor.join();
        }
        checkStop();
        if (r != null) {
            for (IExternalCodeAnalysisVisitor visitor : allVisitors) {
                String problemMarker = visitor.getProblemMarkerId();
                String messageId = visitor.getMessageId();
                List<MarkerInfo> markersFromVisitor = visitor.getMarkers(resource);
                if (markersFromVisitor != null && markersFromVisitor.size() > 0) {
                    Map<Integer, List<MarkerInfo>> lineToMarkerInfo = new HashMap<>();
                    if (markersFromCodeAnalysis != null) {
                        for (MarkerInfo codeAnalysisMarkerInfo : markersFromCodeAnalysis) {
                            List<MarkerInfo> list = lineToMarkerInfo.get(codeAnalysisMarkerInfo.lineStart);
                            if (list == null) {
                                list = new ArrayList<>(2);
                                lineToMarkerInfo.put(codeAnalysisMarkerInfo.lineStart, list);
                            }
                            list.add(codeAnalysisMarkerInfo);
                        }
                    }
                    if (visitor == pyLintVisitor) {
                        // (there's no real point in putting an error twice).
                        for (Iterator<MarkerInfo> visitorMarkerInfoIterator = markersFromVisitor.iterator(); visitorMarkerInfoIterator.hasNext(); ) {
                            MarkerInfo visitorMarkerInfo = visitorMarkerInfoIterator.next();
                            List<MarkerInfo> codeAnalysisMarkers = lineToMarkerInfo.get(visitorMarkerInfo.lineStart);
                            if (codeAnalysisMarkers != null && codeAnalysisMarkers.size() > 0) {
                                for (MarkerInfo codeAnalysisMarker : codeAnalysisMarkers) {
                                    if (codeAnalysisMarker.severity < IMarker.SEVERITY_INFO) {
                                        // Don't consider if it shouldn't be shown.
                                        continue;
                                    }
                                    Map<String, Object> additionalInfo = codeAnalysisMarker.additionalInfo;
                                    if (additionalInfo != null) {
                                        Object analysisType = additionalInfo.get(AnalysisRunner.PYDEV_ANALYSIS_TYPE);
                                        if (analysisType != null && analysisType instanceof Integer) {
                                            String pyLintMessageId = CheckAnalysisErrors.getPyLintMessageIdForPyDevAnalysisType((int) analysisType);
                                            if (pyLintMessageId != null && pyLintMessageId.equals(visitorMarkerInfo.additionalInfo.get(messageId))) {
                                                visitorMarkerInfoIterator.remove();
                                                // Stop the for (we've already removed it).
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    PyMarkerUtils.replaceMarkers(markersFromVisitor, resource, problemMarker, true, this.internalCancelMonitor);
                } else {
                    visitor.deleteMarkers();
                }
            }
        }
    } catch (OperationCanceledException e) {
        // ok, ignore it
        logOperationCancelled();
    } catch (Exception e) {
        Log.log(e);
    } finally {
        try {
            nature.endRequests();
        } catch (Throwable e) {
            Log.log("Error when analyzing: " + moduleName, e);
        }
        try {
            AnalysisBuilderRunnableFactory.removeFromThreads(key, this);
        } catch (Throwable e) {
            Log.log(e);
        }
        dispose();
    }
}