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;
}
public boolean performGuardedChange(Runnable change) {
checkValid();
assert !myChangeGuard : "already in change";
myEditor.getDocument().startGuardedBlockChecking();
myChangeGuard = true;
boolean result;
try {
result = myOffsets.performGuardedChange(change);
} finally {
myEditor.getDocument().stopGuardedBlockChecking();
myChangeGuard = false;
}
if (!result || myDisposed) {
hide();
return false;
}
if (isVisible()) {
HintManagerImpl.updateLocation(this, myEditor, myUi.calculatePosition().getLocation());
}
checkValid();
return true;
}
private static OffsetMap translateOffsetMapToHost(
CompletionInitializationContext initContext,
PsiFile context,
PsiFile hostFile,
Editor hostEditor) {
final InjectedLanguageManager injectedLanguageManager =
InjectedLanguageManager.getInstance(hostFile.getProject());
final OffsetMap hostMap = new OffsetMap(hostEditor.getDocument());
final OffsetMap original = initContext.getOffsetMap();
for (final OffsetKey key : original.getAllOffsets()) {
hostMap.addOffset(
key, injectedLanguageManager.injectedToHost(context, original.getOffset(key)));
}
return hostMap;
}
private static Runnable rememberDocumentState(final Editor _editor) {
final Editor editor = InjectedLanguageUtil.getTopLevelEditor(_editor);
final String documentText = editor.getDocument().getText();
final int caret = editor.getCaretModel().getOffset();
final int selStart = editor.getSelectionModel().getSelectionStart();
final int selEnd = editor.getSelectionModel().getSelectionEnd();
final int vOffset = editor.getScrollingModel().getVerticalScrollOffset();
final int hOffset = editor.getScrollingModel().getHorizontalScrollOffset();
return new Runnable() {
@Override
public void run() {
DocumentEx document = (DocumentEx) editor.getDocument();
document.replaceString(0, document.getTextLength(), documentText);
editor.getCaretModel().moveToOffset(caret);
editor.getSelectionModel().setSelection(selStart, selEnd);
editor.getScrollingModel().scrollHorizontally(hOffset);
editor.getScrollingModel().scrollVertically(vOffset);
}
};
}
private static CompletionAssertions.WatchingInsertionContext insertItemHonorBlockSelection(
final CompletionProgressIndicator indicator,
final LookupElement item,
final char completionChar,
final List<LookupElement> items,
final CompletionLookupArranger.StatisticsUpdate update) {
final Editor editor = indicator.getEditor();
final int caretOffset = editor.getCaretModel().getOffset();
int idEndOffset = indicator.getIdentifierEndOffset();
if (idEndOffset < 0) {
idEndOffset = CompletionInitializationContext.calcDefaultIdentifierEnd(editor, caretOffset);
}
final int idEndOffsetDelta = idEndOffset - caretOffset;
CompletionAssertions.WatchingInsertionContext context = null;
if (editor.getSelectionModel().hasBlockSelection()
&& editor.getSelectionModel().getBlockSelectionEnds().length > 0) {
List<RangeMarker> insertionPoints = new ArrayList<RangeMarker>();
int idDelta = 0;
Document document = editor.getDocument();
int caretLine = document.getLineNumber(editor.getCaretModel().getOffset());
for (int point : editor.getSelectionModel().getBlockSelectionEnds()) {
insertionPoints.add(document.createRangeMarker(point, point));
if (document.getLineNumber(point) == document.getLineNumber(idEndOffset)) {
idDelta = idEndOffset - point;
}
}
List<RangeMarker> caretsAfter = new ArrayList<RangeMarker>();
for (RangeMarker marker : insertionPoints) {
if (marker.isValid()) {
int insertionPoint = marker.getStartOffset();
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
indicator.getParameters().getOriginalFile(),
insertionPoint,
idDelta + insertionPoint);
int offset = editor.getCaretModel().getOffset();
caretsAfter.add(document.createRangeMarker(offset, offset));
}
}
assert context != null;
restoreBlockSelection(editor, caretsAfter, caretLine);
for (RangeMarker insertionPoint : insertionPoints) {
insertionPoint.dispose();
}
for (RangeMarker marker : caretsAfter) {
marker.dispose();
}
} else if (editor.getCaretModel().supportsMultipleCarets()) {
final List<CompletionAssertions.WatchingInsertionContext> contexts =
new ArrayList<CompletionAssertions.WatchingInsertionContext>();
final Editor hostEditor = InjectedLanguageUtil.getTopLevelEditor(editor);
hostEditor
.getCaretModel()
.runForEachCaret(
new CaretAction() {
@Override
public void perform(Caret caret) {
PsiFile hostFile =
InjectedLanguageUtil.getTopLevelFile(
indicator.getParameters().getOriginalFile());
PsiFile targetFile =
InjectedLanguageUtil.findInjectedPsiNoCommit(hostFile, caret.getOffset());
Editor targetEditor =
InjectedLanguageUtil.getInjectedEditorForInjectedFile(hostEditor, targetFile);
int targetCaretOffset = targetEditor.getCaretModel().getOffset();
CompletionAssertions.WatchingInsertionContext currentContext =
insertItem(
indicator,
item,
completionChar,
items,
update,
targetEditor,
targetFile == null ? hostFile : targetFile,
targetCaretOffset,
targetCaretOffset + idEndOffsetDelta);
contexts.add(currentContext);
}
},
true);
context = contexts.get(contexts.size() - 1);
if (context.shouldAddCompletionChar()
&& context.getCompletionChar() != Lookup.COMPLETE_STATEMENT_SELECT_CHAR) {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
DataContext dataContext =
DataManager.getInstance().getDataContext(editor.getContentComponent());
EditorActionManager.getInstance()
.getTypedAction()
.getHandler()
.execute(editor, completionChar, dataContext);
}
});
}
for (CompletionAssertions.WatchingInsertionContext insertionContext : contexts) {
insertionContext.stopWatching();
}
} else {
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
indicator.getParameters().getOriginalFile(),
caretOffset,
idEndOffset);
}
return context;
}
private void insertDummyIdentifier(
final CompletionInitializationContext initContext,
final boolean hasModifiers,
final int invocationCount) {
final PsiFile originalFile = initContext.getFile();
InjectedLanguageManager manager =
InjectedLanguageManager.getInstance(originalFile.getProject());
final PsiFile hostFile = manager.getTopLevelFile(originalFile);
final Editor hostEditor = InjectedLanguageUtil.getTopLevelEditor(initContext.getEditor());
final OffsetMap hostMap =
translateOffsetMapToHost(initContext, originalFile, hostFile, hostEditor);
final PsiFile[] hostCopy = {null};
DocumentUtil.writeInRunUndoTransparentAction(
new Runnable() {
@Override
public void run() {
hostCopy[0] =
createFileCopy(
hostFile, initContext.getStartOffset(), initContext.getSelectionEndOffset());
}
});
final Document copyDocument = hostCopy[0].getViewProvider().getDocument();
assert copyDocument != null : "no document";
final OffsetTranslator translator =
new OffsetTranslator(hostEditor.getDocument(), initContext.getFile(), copyDocument);
CompletionAssertions.checkEditorValid(initContext.getEditor());
CommandProcessor.getInstance()
.runUndoTransparentAction(
new Runnable() {
@Override
public void run() {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
String dummyIdentifier = initContext.getDummyIdentifier();
if (StringUtil.isEmpty(dummyIdentifier)) return;
int startOffset =
hostMap.getOffset(CompletionInitializationContext.START_OFFSET);
int endOffset =
hostMap.getOffset(
CompletionInitializationContext.SELECTION_END_OFFSET);
copyDocument.replaceString(startOffset, endOffset, dummyIdentifier);
}
});
}
});
CompletionAssertions.checkEditorValid(initContext.getEditor());
final Project project = originalFile.getProject();
if (!synchronous) {
if (CompletionServiceImpl.isPhase(CompletionPhase.NoCompletion.getClass())
|| !CompletionServiceImpl.assertPhase(CompletionPhase.CommittingDocuments.class)) {
Disposer.dispose(translator);
return;
}
final CompletionPhase.CommittingDocuments phase =
(CompletionPhase.CommittingDocuments) CompletionServiceImpl.getCompletionPhase();
CompletionAutoPopupHandler.runLaterWithCommitted(
project,
copyDocument,
new Runnable() {
@Override
public void run() {
if (phase.checkExpired()) {
Disposer.dispose(translator);
return;
}
doComplete(
initContext, hasModifiers, invocationCount, hostCopy[0], hostMap, translator);
}
});
} else {
PsiDocumentManager.getInstance(project).commitDocument(copyDocument);
doComplete(initContext, hasModifiers, invocationCount, hostCopy[0], hostMap, translator);
}
}
public final void invokeCompletion(
@NotNull final Project project,
@NotNull final Editor editor,
int time,
boolean hasModifiers,
boolean restarted,
@NotNull final Caret caret) {
markCaretAsProcessed(caret);
if (invokedExplicitly) {
CompletionLookupArranger.applyLastCompletionStatisticsUpdate();
}
checkNoWriteAccess();
CompletionAssertions.checkEditorValid(editor);
int offset = editor.getCaretModel().getOffset();
if (editor.isViewer() || editor.getDocument().getRangeGuard(offset, offset) != null) {
editor.getDocument().fireReadOnlyModificationAttempt();
CodeInsightUtilBase.showReadOnlyViewWarning(editor);
return;
}
if (!FileDocumentManager.getInstance().requestWriting(editor.getDocument(), project)) {
return;
}
CompletionPhase phase = CompletionServiceImpl.getCompletionPhase();
boolean repeated =
phase.indicator != null && phase.indicator.isRepeatedInvocation(myCompletionType, editor);
/*
if (repeated && isAutocompleteCommonPrefixOnInvocation() && phase.fillInCommonPrefix()) {
return;
}
*/
final int newTime = phase.newCompletionStarted(time, repeated);
if (invokedExplicitly) {
time = newTime;
}
final int invocationCount = time;
if (CompletionServiceImpl.isPhase(CompletionPhase.InsertedSingleItem.class)) {
CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
}
CompletionServiceImpl.assertPhase(
CompletionPhase.NoCompletion.getClass(), CompletionPhase.CommittingDocuments.class);
if (invocationCount > 1 && myCompletionType == CompletionType.BASIC) {
FeatureUsageTracker.getInstance()
.triggerFeatureUsed(CodeCompletionFeatures.SECOND_BASIC_COMPLETION);
}
final CompletionInitializationContext[] initializationContext = {null};
Runnable initCmd =
new Runnable() {
@Override
public void run() {
Runnable runnable =
new Runnable() {
@Override
public void run() {
EditorUtil.fillVirtualSpaceUntilCaret(editor);
PsiDocumentManager.getInstance(project).commitAllDocuments();
CompletionAssertions.checkEditorValid(editor);
final PsiFile psiFile = PsiUtilBase.getPsiFileInEditor(caret, project);
assert psiFile != null
: "no PSI file: "
+ FileDocumentManager.getInstance().getFile(editor.getDocument());
psiFile.putUserData(PsiFileEx.BATCH_REFERENCE_PROCESSING, Boolean.TRUE);
CompletionAssertions.assertCommitSuccessful(editor, psiFile);
initializationContext[0] =
runContributorsBeforeCompletion(editor, psiFile, invocationCount, caret);
}
};
ApplicationManager.getApplication().runWriteAction(runnable);
}
};
if (autopopup) {
CommandProcessor.getInstance().runUndoTransparentAction(initCmd);
if (!restarted && shouldSkipAutoPopup(editor, initializationContext[0].getFile())) {
CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
return;
}
} else {
CommandProcessor.getInstance().executeCommand(project, initCmd, null, null);
}
insertDummyIdentifier(initializationContext[0], hasModifiers, invocationCount);
}
private void addListeners() {
myEditor
.getDocument()
.addDocumentListener(
new DocumentAdapter() {
@Override
public void documentChanged(DocumentEvent e) {
if (!myChangeGuard && !myFinishing) {
hide();
}
}
},
this);
final CaretListener caretListener =
new CaretAdapter() {
@Override
public void caretPositionChanged(CaretEvent e) {
if (!myChangeGuard && !myFinishing) {
hide();
}
}
};
final SelectionListener selectionListener =
new SelectionListener() {
@Override
public void selectionChanged(final SelectionEvent e) {
if (!myChangeGuard && !myFinishing) {
hide();
}
}
};
final EditorMouseListener mouseListener =
new EditorMouseAdapter() {
@Override
public void mouseClicked(EditorMouseEvent e) {
e.consume();
hide();
}
};
myEditor.getCaretModel().addCaretListener(caretListener);
myEditor.getSelectionModel().addSelectionListener(selectionListener);
myEditor.addEditorMouseListener(mouseListener);
Disposer.register(
this,
new Disposable() {
@Override
public void dispose() {
myEditor.getCaretModel().removeCaretListener(caretListener);
myEditor.getSelectionModel().removeSelectionListener(selectionListener);
myEditor.removeEditorMouseListener(mouseListener);
}
});
JComponent editorComponent = myEditor.getContentComponent();
if (editorComponent.isShowing()) {
Disposer.register(
this,
new UiNotifyConnector(
editorComponent,
new Activatable() {
@Override
public void showNotify() {}
@Override
public void hideNotify() {
hideLookup(false);
}
}));
}
myList.addListSelectionListener(
new ListSelectionListener() {
private LookupElement oldItem = null;
@Override
public void valueChanged(@NotNull ListSelectionEvent e) {
if (!myUpdating) {
final LookupElement item = getCurrentItem();
fireCurrentItemChanged(oldItem, item);
oldItem = item;
}
}
});
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent e, int clickCount) {
setFocusDegree(FocusDegree.FOCUSED);
markSelectionTouched();
if (clickCount == 2) {
CommandProcessor.getInstance()
.executeCommand(
myProject,
new Runnable() {
@Override
public void run() {
finishLookup(NORMAL_SELECT_CHAR);
}
},
"",
null);
}
return true;
}
}.installOn(myList);
}
@Override
@Nullable
public PsiFile getPsiFile() {
return PsiDocumentManager.getInstance(myProject).getPsiFile(myEditor.getDocument());
}
private static CompletionAssertions.WatchingInsertionContext insertItemHonorBlockSelection(
final CompletionProgressIndicator indicator,
final LookupElement item,
final char completionChar,
final List<LookupElement> items,
final CompletionLookupArranger.StatisticsUpdate update) {
final Editor editor = indicator.getEditor();
final int caretOffset = editor.getCaretModel().getOffset();
int idEndOffset = indicator.getIdentifierEndOffset();
if (idEndOffset < 0) {
idEndOffset = CompletionInitializationContext.calcDefaultIdentifierEnd(editor, caretOffset);
}
final int idEndOffsetDelta = idEndOffset - caretOffset;
CompletionAssertions.WatchingInsertionContext context = null;
if (editor.getSelectionModel().hasBlockSelection()
&& editor.getSelectionModel().getBlockSelectionEnds().length > 0) {
List<RangeMarker> insertionPoints = new ArrayList<RangeMarker>();
int idDelta = 0;
Document document = editor.getDocument();
int caretLine = document.getLineNumber(editor.getCaretModel().getOffset());
for (int point : editor.getSelectionModel().getBlockSelectionEnds()) {
insertionPoints.add(document.createRangeMarker(point, point));
if (document.getLineNumber(point) == document.getLineNumber(idEndOffset)) {
idDelta = idEndOffset - point;
}
}
List<RangeMarker> caretsAfter = new ArrayList<RangeMarker>();
for (RangeMarker marker : insertionPoints) {
if (marker.isValid()) {
int insertionPoint = marker.getStartOffset();
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
insertionPoint,
idDelta + insertionPoint);
int offset = editor.getCaretModel().getOffset();
caretsAfter.add(document.createRangeMarker(offset, offset));
}
}
assert context != null;
restoreBlockSelection(editor, caretsAfter, caretLine);
for (RangeMarker insertionPoint : insertionPoints) {
insertionPoint.dispose();
}
for (RangeMarker marker : caretsAfter) {
marker.dispose();
}
} else {
final Ref<CompletionAssertions.WatchingInsertionContext> contextRef =
new Ref<CompletionAssertions.WatchingInsertionContext>();
editor
.getCaretModel()
.runForEachCaret(
new CaretAction() {
@Override
public void perform(Caret caret) {
CompletionAssertions.WatchingInsertionContext currentContext =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
caret.getOffset(),
caret.getOffset() + idEndOffsetDelta);
if (caret
.getVisualPosition()
.equals(editor.getCaretModel().getPrimaryCaret().getVisualPosition())) {
contextRef.set(currentContext);
}
}
});
context = contextRef.get();
}
return context;
}
private static CompletionAssertions.WatchingInsertionContext insertItemHonorBlockSelection(
CompletionProgressIndicator indicator,
LookupElement item,
char completionChar,
List<LookupElement> items,
CompletionLookupArranger.StatisticsUpdate update) {
final Editor editor = indicator.getEditor();
final int caretOffset = editor.getCaretModel().getOffset();
int idEndOffset = indicator.getIdentifierEndOffset();
if (idEndOffset < 0) {
idEndOffset = CompletionInitializationContext.calcDefaultIdentifierEnd(editor, caretOffset);
}
CompletionAssertions.WatchingInsertionContext context = null;
if (editor.getSelectionModel().hasBlockSelection()
&& editor.getSelectionModel().getBlockSelectionEnds().length > 0) {
List<RangeMarker> insertionPoints = new ArrayList<RangeMarker>();
int idDelta = 0;
Document document = editor.getDocument();
int caretLine = document.getLineNumber(editor.getCaretModel().getOffset());
for (int point : editor.getSelectionModel().getBlockSelectionEnds()) {
insertionPoints.add(document.createRangeMarker(point, point));
if (document.getLineNumber(point) == document.getLineNumber(idEndOffset)) {
idDelta = idEndOffset - point;
}
}
List<RangeMarker> caretsAfter = new ArrayList<RangeMarker>();
for (RangeMarker marker : insertionPoints) {
if (marker.isValid()) {
int insertionPoint = marker.getStartOffset();
context =
insertItem(
indicator,
item,
completionChar,
items,
update,
editor,
insertionPoint,
idDelta + insertionPoint);
int offset = editor.getCaretModel().getOffset();
caretsAfter.add(document.createRangeMarker(offset, offset));
}
}
assert context != null;
restoreBlockSelection(editor, caretsAfter, caretLine);
for (RangeMarker insertionPoint : insertionPoints) {
insertionPoint.dispose();
}
for (RangeMarker marker : caretsAfter) {
marker.dispose();
}
} else {
context =
insertItem(
indicator, item, completionChar, items, update, editor, caretOffset, idEndOffset);
}
return context;
}