protected void doRun( @NotNull final ExecutionEnvironment environment, @NotNull final Runnable startRunnable) { Boolean allowSkipRun = environment.getUserData(EXECUTION_SKIP_RUN); if (allowSkipRun != null && allowSkipRun) { environment .getProject() .getMessageBus() .syncPublisher(EXECUTION_TOPIC) .processNotStarted(environment.getExecutor().getId(), environment); } else { // important! Do not use DumbService.smartInvokeLater here because it depends on modality // state // and execution of startRunnable could be skipped if modality state check fails //noinspection SSBasedInspection SwingUtilities.invokeLater( () -> { if (!myProject.isDisposed()) { if (!Registry.is("dumb.aware.run.configurations")) { DumbService.getInstance(myProject).runWhenSmart(startRunnable); } else { try { DumbService.getInstance(myProject).setAlternativeResolveEnabled(true); startRunnable.run(); } catch (IndexNotReadyException ignored) { ExecutionUtil.handleExecutionError( environment, new ExecutionException("cannot start while indexing is in progress.")); } finally { DumbService.getInstance(myProject).setAlternativeResolveEnabled(false); } } } }); } }
@Override public void invoke( @NotNull final Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiDocumentManager.getInstance(project).commitAllDocuments(); DumbService.getInstance(project).setAlternativeResolveEnabled(true); try { int offset = editor.getCaretModel().getOffset(); PsiElement[] elements = underModalProgress( project, "Resolving Reference...", () -> findAllTargetElements(project, editor, offset)); FeatureUsageTracker.getInstance().triggerFeatureUsed("navigation.goto.declaration"); if (elements.length != 1) { if (elements.length == 0 && suggestCandidates(TargetElementUtil.findReference(editor, offset)).isEmpty()) { PsiElement element = findElementToShowUsagesOf(editor, editor.getCaretModel().getOffset()); if (startFindUsages(editor, element)) { return; } // disable 'no declaration found' notification for keywords final PsiElement elementAtCaret = file.findElementAt(offset); if (elementAtCaret != null) { final NamesValidator namesValidator = LanguageNamesValidation.INSTANCE.forLanguage(elementAtCaret.getLanguage()); if (namesValidator != null && namesValidator.isKeyword(elementAtCaret.getText(), project)) { return; } } } chooseAmbiguousTarget(editor, offset, elements, file); return; } PsiElement element = elements[0]; if (element == findElementToShowUsagesOf(editor, editor.getCaretModel().getOffset()) && startFindUsages(editor, element)) { return; } PsiElement navElement = element.getNavigationElement(); navElement = TargetElementUtil.getInstance().getGotoDeclarationTarget(element, navElement); if (navElement != null) { gotoTargetElement(navElement, editor, file); } } catch (IndexNotReadyException e) { DumbService.getInstance(project) .showDumbModeNotification("Navigation is not available here during index update"); } finally { DumbService.getInstance(project).setAlternativeResolveEnabled(false); } }
@Nullable @Override public PhpType getType(PsiElement e) { if (DumbService.getInstance(e.getProject()).isDumb()) { return null; } if (!ContainerGetHelper.isContainerGetCall(e)) { return null; } String serviceId = ContainerGetHelper.getServiceId((MethodReference) e); if (null == serviceId) { return null; } Symfony2ProjectComponent symfony2ProjectComponent = e.getProject().getComponent(Symfony2ProjectComponent.class); ServiceMap serviceMap = symfony2ProjectComponent.getServicesMap(); if (null == serviceMap) { return null; } String serviceClass = serviceMap.getMap().get(serviceId); if (null == serviceClass) { return null; } return new PhpType().add(serviceClass); }
public static void addJarsToRootsAndImportClass( @NotNull List<String> jarPaths, final String libraryName, @NotNull final Module currentModule, @Nullable final Editor editor, @Nullable final PsiReference reference, @Nullable @NonNls final String className) { addJarsToRoots( jarPaths, libraryName, currentModule, reference != null ? reference.getElement() : null); final Project project = currentModule.getProject(); if (editor != null && reference != null && className != null) { DumbService.getInstance(project) .withAlternativeResolveEnabled( new Runnable() { @Override public void run() { GlobalSearchScope scope = GlobalSearchScope.moduleWithLibrariesScope(currentModule); PsiClass aClass = JavaPsiFacade.getInstance(project).findClass(className, scope); if (aClass != null) { new AddImportAction(project, reference, editor, aClass).execute(); } } }); } }
@Nullable @Override public String getType(PsiElement e) { if (DumbService.getInstance(e.getProject()).isDumb() || !Settings.getInstance(e.getProject()).pluginEnabled || !Settings.getInstance(e.getProject()).objectManagerFindTypeProvider) { return null; } if (!(e instanceof MethodReference) || !PhpElementsUtil.isMethodWithFirstStringOrFieldReference(e, "find")) { return null; } String refSignature = ((MethodReference) e).getSignature(); if (StringUtil.isEmpty(refSignature)) { return null; } // we need the param key on getBySignature(), since we are already in the resolved method there // attach it to signature // param can have dotted values split with \ PsiElement[] parameters = ((MethodReference) e).getParameters(); if (parameters.length == 2) { return PhpTypeProviderUtil.getReferenceSignature((MethodReference) e, TRIM_KEY, 2); } return null; }
public synchronized void runPostStartupActivities() { final Application app = ApplicationManager.getApplication(); app.assertIsDispatchThread(); if (myPostStartupActivitiesPassed) return; runActivities(myDumbAwarePostStartupActivities); DumbService.getInstance(myProject) .runWhenSmart( new Runnable() { public void run() { synchronized (StartupManagerImpl.this) { app.assertIsDispatchThread(); if (myProject.isDisposed()) return; runActivities( myDumbAwarePostStartupActivities); // they can register activities while in // the dumb mode runActivities(myNotDumbAwarePostStartupActivities); myPostStartupActivitiesPassed = true; } } }); if (!app.isUnitTestMode()) { VirtualFileManager.getInstance().refresh(!app.isHeadlessEnvironment()); } }
@Override public void run(@NotNull ProgressIndicator indicator) { try { mySocket = myServerSocket.accept(); final ExecutionException[] ex = new ExecutionException[1]; DumbService.getInstance(getProject()) .repeatUntilPassesInSmartMode( new Runnable() { @Override public void run() { try { search(); } catch (ExecutionException e) { ex[0] = e; } } }); if (ex[0] != null) { logCantRunException(ex[0]); } } catch (ProcessCanceledException e) { throw e; } catch (IOException e) { LOG.info(e); } catch (Throwable e) { LOG.error(e); } }
private boolean checkUnderReadAction( final MyValidatorProcessingItem item, final CompileContext context, final Computable<Map<ProblemDescriptor, HighlightDisplayLevel>> runnable) { return DumbService.getInstance(context.getProject()) .runReadActionInSmartMode( new Computable<Boolean>() { @Override public Boolean compute() { final PsiFile file = item.getPsiFile(); if (file == null) return false; final Document document = myPsiDocumentManager.getCachedDocument(file); if (document != null && myPsiDocumentManager.isUncommited(document)) { final String url = file.getViewProvider().getVirtualFile().getUrl(); context.addMessage( CompilerMessageCategory.WARNING, CompilerBundle.message("warning.text.file.has.been.changed"), url, -1, -1); return false; } if (reportProblems(context, runnable.compute())) return false; return true; } }); }
private CompletionInitializationContext runContributorsBeforeCompletion( Editor editor, PsiFile psiFile, int invocationCount, Caret caret) { final Ref<CompletionContributor> current = Ref.create(null); CompletionInitializationContext context = new CompletionInitializationContext( editor, caret, psiFile, myCompletionType, invocationCount) { CompletionContributor dummyIdentifierChanger; @Override public void setDummyIdentifier(@NotNull String dummyIdentifier) { super.setDummyIdentifier(dummyIdentifier); if (dummyIdentifierChanger != null) { LOG.error( "Changing the dummy identifier twice, already changed by " + dummyIdentifierChanger); } dummyIdentifierChanger = current.get(); } }; List<CompletionContributor> contributors = CompletionContributor.forLanguage(context.getPositionLanguage()); Project project = psiFile.getProject(); List<CompletionContributor> filteredContributors = DumbService.getInstance(project).filterByDumbAwareness(contributors); for (final CompletionContributor contributor : filteredContributors) { current.set(contributor); contributor.beforeCompletion(context); CompletionAssertions.checkEditorValid(editor); assert !PsiDocumentManager.getInstance(project).isUncommited(editor.getDocument()) : "Contributor " + contributor + " left the document uncommitted"; } return context; }
private void updateWarnings(@NotNull final MPSFileNodeEditor editor) { DumbService.getInstance(myProject) .smartInvokeLater( new Runnable() { @Override public void run() { final Runnable task = new Runnable() { @Override public void run() { doUpdateWarnings(editor); } }; Boolean aBoolean = ModelAccess.instance() .tryRead( new Computable<Boolean>() { @Override public Boolean compute() { task.run(); return Boolean.TRUE; } }); if (aBoolean == null) { ModelAccess.instance().runReadInEDT(task); } } }); }
public Pair<RenderResources, RenderResources> createResourceResolver( final AndroidFacet facet, FolderConfiguration config, ProjectResources projectResources, String themeName, boolean isProjectTheme) { final Map<ResourceType, Map<String, ResourceValue>> configedProjectRes = projectResources.getConfiguredResources(config); DumbService.getInstance(facet.getModule().getProject()).waitForSmartMode(); final Collection<String> ids = ApplicationManager.getApplication() .runReadAction( new Computable<Collection<String>>() { @Override public Collection<String> compute() { return facet.getLocalResourceManager().getIds(); } }); final Map<String, ResourceValue> map = configedProjectRes.get(ResourceType.ID); for (String id : ids) { if (!map.containsKey(id)) { map.put(id, new ResourceValue(ResourceType.ID, id, false)); } } final Map<ResourceType, Map<String, ResourceValue>> configedFrameworkRes = myResources.getConfiguredResources(config); final ResourceResolver resolver = ResourceResolver.create( configedProjectRes, configedFrameworkRes, themeName, isProjectTheme); return new Pair<RenderResources, RenderResources>( new ResourceResolverDecorator(resolver), resolver); }
@Override public void selectionChanged(@NotNull FileEditorManagerEvent event) { final FileEditor newFileEditor = event.getNewEditor(); Editor mxmlEditor = null; if (newFileEditor instanceof TextEditor) { final Editor editor = ((TextEditor) newFileEditor).getEditor(); if (DesignerApplicationManager.dumbAwareIsApplicable( project, PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument()))) { mxmlEditor = editor; } } if (mxmlEditor == null) { processFileEditorChange(null); return; } final DumbService dumbService = DumbService.getInstance(project); if (dumbService.isDumb()) { openWhenSmart(dumbService); } else { if (!isApplicableEditor(mxmlEditor)) { mxmlEditor = null; } processFileEditorChange(mxmlEditor); } }
public final void invokeCompletion(final Project project, final Editor editor) { try { invokeCompletion(project, editor, 1); } catch (IndexNotReadyException e) { DumbService.getInstance(project) .showDumbModeNotification( "Code completion is not available here while indices are being built"); } }
public boolean processAction(final InputEvent e, ActionProcessor processor) { ActionManagerEx actionManager = ActionManagerEx.getInstanceEx(); final Project project = PlatformDataKeys.PROJECT.getData(myContext.getDataContext()); final boolean dumb = project != null && DumbService.getInstance(project).isDumb(); List<AnActionEvent> nonDumbAwareAction = new ArrayList<AnActionEvent>(); for (final AnAction action : myContext.getActions()) { final Presentation presentation = myPresentationFactory.getPresentation(action); // Mouse modifiers are 0 because they have no any sense when action is invoked via keyboard final AnActionEvent actionEvent = processor.createEvent( e, myContext.getDataContext(), ActionPlaces.MAIN_MENU, presentation, ActionManager.getInstance()); ActionUtil.performDumbAwareUpdate(action, actionEvent, true); if (dumb && !action.isDumbAware()) { if (Boolean.FALSE.equals( presentation.getClientProperty(ActionUtil.WOULD_BE_ENABLED_IF_NOT_DUMB_MODE))) { continue; } nonDumbAwareAction.add(actionEvent); continue; } if (!presentation.isEnabled()) { continue; } processor.onUpdatePassed(e, action, actionEvent); ((DataManagerImpl.MyDataContext) myContext.getDataContext()) .setEventCount(IdeEventQueue.getInstance().getEventCount(), this); actionManager.fireBeforeActionPerformed(action, actionEvent.getDataContext(), actionEvent); Component component = PlatformDataKeys.CONTEXT_COMPONENT.getData(actionEvent.getDataContext()); if (component != null && !component.isShowing()) { return true; } processor.performAction(e, action, actionEvent); actionManager.fireAfterActionPerformed(action, actionEvent.getDataContext(), actionEvent); return true; } if (!nonDumbAwareAction.isEmpty()) { showDumbModeWarningLaterIfNobodyConsumesEvent( e, nonDumbAwareAction.toArray(new AnActionEvent[nonDumbAwareAction.size()])); } return false; }
// queue each activity in smart mode separately so that if one of them starts dumb mode, the next // ones just wait for it to finish private void queueSmartModeActivity(final Runnable activity) { DumbService.getInstance(myProject) .runWhenSmart( new Runnable() { @Override public void run() { runActivity(activity); } }); }
public static <T> T underModalProgress( @NotNull Project project, @NotNull @Nls(capitalization = Nls.Capitalization.Title) String progressTitle, @NotNull Computable<T> computable) throws ProcessCanceledException { return ProgressManager.getInstance() .runProcessWithProgressSynchronously( () -> { DumbService.getInstance(project).setAlternativeResolveEnabled(true); try { return ApplicationManager.getApplication().runReadAction(computable); } finally { DumbService.getInstance(project).setAlternativeResolveEnabled(false); } }, progressTitle, true, project); }
@NotNull private KotlinPsiElementFinderWrapper[] filteredFinders() { DumbService dumbService = DumbService.getInstance(getProject()); KotlinPsiElementFinderWrapper[] finders = finders(); if (dumbService.isDumb()) { List<KotlinPsiElementFinderWrapper> list = dumbService.filterByDumbAwareness(Arrays.asList(finders)); finders = list.toArray(new KotlinPsiElementFinderWrapper[list.size()]); } return finders; }
@Override @NotNull public ProcessingItem[] getProcessingItems(final CompileContext context) { final Project project = context.getProject(); if (project.isDefault() || !ValidationConfiguration.shouldValidate(this, context)) { return ProcessingItem.EMPTY_ARRAY; } final ExcludesConfiguration excludesConfiguration = ValidationConfiguration.getExcludedEntriesConfiguration(project); final List<ProcessingItem> items = DumbService.getInstance(project) .runReadActionInSmartMode( new Computable<List<ProcessingItem>>() { @Override public List<ProcessingItem> compute() { final CompileScope compileScope = context.getCompileScope(); if (!myValidator.isAvailableOnScope(compileScope)) return null; final ArrayList<ProcessingItem> items = new ArrayList<ProcessingItem>(); final Processor<VirtualFile> processor = new Processor<VirtualFile>() { @Override public boolean process(VirtualFile file) { if (!file.isValid()) { return true; } if (myCompilerManager.isExcludedFromCompilation(file) || excludesConfiguration.isExcluded(file)) { return true; } final Module module = context.getModuleByFile(file); if (module != null) { final PsiFile psiFile = myPsiManager.findFile(file); if (psiFile != null) { items.add(new MyValidatorProcessingItem(psiFile)); } } return true; } }; ContainerUtil.process( myValidator.getFilesToProcess(myPsiManager.getProject(), context), processor); return items; } }); if (items == null) return ProcessingItem.EMPTY_ARRAY; return items.toArray(new ProcessingItem[items.size()]); }
@Override @Nullable public ObjectStubTree readFromVFile(Project project, final VirtualFile vFile) { if (DumbService.getInstance(project).isDumb()) { return null; } final int id = Math.abs(FileBasedIndex.getFileId(vFile)); if (id <= 0) { return null; } boolean wasIndexedAlready = FileBasedIndexImpl.isFileIndexed(vFile, StubUpdatingIndex.INDEX_ID); final List<SerializedStubTree> datas = FileBasedIndex.getInstance() .getValues(StubUpdatingIndex.INDEX_ID, id, GlobalSearchScope.fileScope(project, vFile)); final int size = datas.size(); if (size == 1) { Stub stub; try { stub = datas.get(0).getStub(false); } catch (SerializerNotFoundException e) { return processError( vFile, "No stub serializer: " + vFile.getPresentableUrl() + ": " + e.getMessage(), e); } ObjectStubTree tree = stub instanceof PsiFileStub ? new StubTree((PsiFileStub) stub) : new ObjectStubTree((ObjectStubBase) stub, true); tree.setDebugInfo( "created from index: " + StubUpdatingIndex.getIndexingStampInfo(vFile) + ", wasIndexedAlready=" + wasIndexedAlready + ", queried at " + vFile.getTimeStamp()); return tree; } else if (size != 0) { return processError( vFile, "Twin stubs: " + vFile.getPresentableUrl() + " has " + size + " stub versions. Should only have one. id=" + id, null); } return null; }
@Override public void onSuccess() { DumbService.getInstance(getProject()) .runWhenSmart( new Runnable() { @Override public void run() { onFound(); finish(); startListening(); } }); }
private void addAlarmRequest() { Runnable request = () -> { if (!myDisposed && !myProject.isDisposed()) { PsiDocumentManager.getInstance(myProject) .performLaterWhenAllCommitted( () -> DumbService.getInstance(myProject) .withAlternativeResolveEnabled(this::updateComponent)); } }; myAlarm.addRequest(request, DELAY, ModalityState.stateForComponent(myEditor.getComponent())); }
void duringCompletion(CompletionInitializationContext initContext) { if (isAutopopupCompletion()) { if (shouldFocusLookup(myParameters)) { myLookup.setFocused(true); } else if (FeatureUsageTracker.getInstance() .isToBeAdvertisedInLookup( CodeCompletionFeatures.EDITING_COMPLETION_CONTROL_ENTER, getProject())) { myLookup.addAdvertisement( "Press " + CompletionContributor.getActionShortcut( IdeActions.ACTION_CHOOSE_LOOKUP_ITEM_ALWAYS) + " to choose the first suggestion"); } if (!myEditor.isOneLineMode() && FeatureUsageTracker.getInstance() .isToBeAdvertisedInLookup( CodeCompletionFeatures.EDITING_COMPLETION_CONTROL_ARROWS, getProject())) { myLookup.addAdvertisement( CompletionContributor.getActionShortcut(IdeActions.ACTION_LOOKUP_DOWN) + " and " + CompletionContributor.getActionShortcut(IdeActions.ACTION_LOOKUP_UP) + " will move caret down and up in the editor"); } } ProgressManager.checkCanceled(); if (!initContext .getOffsetMap() .wasModified(CompletionInitializationContext.IDENTIFIER_END_OFFSET)) { try { final int selectionEndOffset = initContext.getSelectionEndOffset(); final PsiReference reference = initContext.getFile().findReferenceAt(selectionEndOffset); if (reference != null) { initContext.setReplacementOffset(findReplacementOffset(selectionEndOffset, reference)); } } catch (IndexNotReadyException ignored) { } } for (CompletionContributor contributor : CompletionContributor.forLanguage(initContext.getPositionLanguage())) { ProgressManager.checkCanceled(); if (DumbService.getInstance(initContext.getProject()).isDumb() && !DumbService.isDumbAware(contributor)) { continue; } contributor.duringCompletion(initContext); } }
@Override public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { FeatureUsageTracker.getInstance().triggerFeatureUsed(getFeatureUsedKey()); try { GotoData gotoData = getSourceAndTargetElements(editor, file); if (gotoData != null) { show(project, editor, file, gotoData); } } catch (IndexNotReadyException e) { DumbService.getInstance(project) .showDumbModeNotification("Navigation is not available here during index update"); } }
private void _updateFilters() { try { updateFilters(); } catch (ProcessCanceledException e) { DumbService.getInstance(myProject) .smartInvokeLater( new Runnable() { public void run() { _updateFilters(); } }, ModalityState.NON_MODAL); } }
public static void runDumbAware(final Project project, final Runnable r) { if (DumbService.isDumbAware(r)) { r.run(); } else { DumbService.getInstance(project) .runWhenSmart( new Runnable() { public void run() { if (project.isDisposed()) return; r.run(); } }); } }
public final void applyInformationToEditor() { if (!isValid()) return; // Document has changed. if (DumbService.getInstance(myProject).isDumb() && !(this instanceof DumbAware)) { Document document = getDocument(); PsiFile file = document == null ? null : PsiDocumentManager.getInstance(myProject).getPsiFile(document); if (file != null) { ((DaemonCodeAnalyzerImpl) DaemonCodeAnalyzer.getInstance(myProject)) .getFileStatusMap() .markFileUpToDate(file.getProject(), getDocument(), getId()); } return; } doApplyInformationToEditor(); }
private static HighlightVisitor[] filterVisitors( HighlightVisitor[] highlightVisitors, final PsiFile file) { final List<HighlightVisitor> visitors = new ArrayList<HighlightVisitor>(highlightVisitors.length); List<HighlightVisitor> list = Arrays.asList(highlightVisitors); for (HighlightVisitor visitor : DumbService.getInstance(file.getProject()).filterByDumbAwareness(list)) { if (visitor.suitableForFile(file)) visitors.add(visitor); } LOG.assertTrue(!visitors.isEmpty(), list); HighlightVisitor[] visitorArray = visitors.toArray(new HighlightVisitor[visitors.size()]); Arrays.sort(visitorArray, VISITOR_ORDER_COMPARATOR); return visitorArray; }
public static FoldingDescriptor[] buildFoldingDescriptors( FoldingBuilder builder, PsiElement root, Document document, boolean quick) { if (!(builder instanceof DumbAware) && DumbService.getInstance(root.getProject()).isDumb()) { return FoldingDescriptor.EMPTY; } if (builder instanceof FoldingBuilderEx) { return ((FoldingBuilderEx) builder).buildFoldRegions(root, document, quick); } final ASTNode astNode = root.getNode(); if (astNode == null) { return FoldingDescriptor.EMPTY; } return builder.buildFoldRegions(astNode, document); }
protected boolean isAvailable(final DataContext dataContext) { final Project project = CommonDataKeys.PROJECT.getData(dataContext); if (project == null) { return false; } if (DumbService.getInstance(project).isDumb() && !isDumbAware()) { return false; } final IdeView view = LangDataKeys.IDE_VIEW.getData(dataContext); if (view == null || view.getDirectories().length == 0) { return false; } return true; }
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(); } }