protected void addLookupItem(
Set<LookupElement> set,
TailType tailType,
@NotNull Object completion,
final PsiFile file,
final CompletionVariant variant) {
LookupElement ret = objectToLookupItem(completion);
if (ret == null) return;
if (!(ret instanceof LookupItem)) {
set.add(ret);
return;
}
LookupItem item = (LookupItem) ret;
final InsertHandler insertHandler = variant.getInsertHandler();
if (insertHandler != null && item.getInsertHandler() == null) {
item.setInsertHandler(insertHandler);
item.setTailType(TailType.UNKNOWN);
} else if (tailType != TailType.NONE) {
item.setTailType(tailType);
}
final Map<Object, Object> itemProperties = variant.getItemProperties();
for (final Object key : itemProperties.keySet()) {
item.setAttribute(key, itemProperties.get(key));
}
set.add(ret);
}
public void fillCompletions(
CompletionParameters parameters, final Consumer<LookupElement> result) {
final PsiElement position = parameters.getPosition();
if (PsiTreeUtil.getParentOfType(position, PsiComment.class, false) != null) {
return;
}
PsiStatement statement = PsiTreeUtil.getParentOfType(position, PsiExpressionStatement.class);
if (statement == null) {
statement = PsiTreeUtil.getParentOfType(position, PsiDeclarationStatement.class);
}
PsiElement prevLeaf = PsiTreeUtil.prevVisibleLeaf(position);
if (statement != null
&& statement.getTextRange().getStartOffset() == position.getTextRange().getStartOffset()) {
if (!psiElement()
.withSuperParent(2, PsiSwitchStatement.class)
.afterLeaf("{")
.accepts(statement)) {
PsiTryStatement tryStatement = PsiTreeUtil.getParentOfType(prevLeaf, PsiTryStatement.class);
if (tryStatement == null
|| tryStatement.getCatchSections().length > 0
|| tryStatement.getFinallyBlock() != null) {
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.FINAL), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
}
}
if (isStatementPosition(position)) {
if (PsiTreeUtil.getParentOfType(position, PsiSwitchStatement.class, false, PsiMember.class)
!= null) {
result.consume(
new OverrideableSpace(createKeyword(position, PsiKeyword.CASE), TailType.INSERT_SPACE));
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.DEFAULT), TailType.CASE_COLON));
if (START_SWITCH.accepts(position)) {
return;
}
}
addBreakContinue(result, position);
addStatementKeywords(result, position);
}
if (SUPER_OR_THIS_PATTERN.accepts(position)) {
final boolean afterDot = AFTER_DOT.accepts(position);
final boolean insideQualifierClass = isInsideQualifierClass(position);
final boolean insideInheritorClass =
PsiUtil.isLanguageLevel8OrHigher(position) && isInsideInheritorClass(position);
if (!afterDot || insideQualifierClass || insideInheritorClass) {
if (!afterDot || insideQualifierClass) {
result.consume(createKeyword(position, PsiKeyword.THIS));
}
final LookupItem superItem = (LookupItem) createKeyword(position, PsiKeyword.SUPER);
if (psiElement()
.afterLeaf(psiElement().withText("{").withSuperParent(2, psiMethod().constructor(true)))
.accepts(position)) {
final PsiMethod method =
PsiTreeUtil.getParentOfType(position, PsiMethod.class, false, PsiClass.class);
assert method != null;
final boolean hasParams = superConstructorHasParameters(method);
superItem.setInsertHandler(
new ParenthesesInsertHandler<LookupElement>() {
@Override
protected boolean placeCaretInsideParentheses(
InsertionContext context, LookupElement item) {
return hasParams;
}
@Override
public void handleInsert(InsertionContext context, LookupElement item) {
super.handleInsert(context, item);
TailType.insertChar(context.getEditor(), context.getTailOffset(), ';');
}
});
}
result.consume(superItem);
}
}
if (isExpressionPosition(position)) {
if (PsiTreeUtil.getParentOfType(position, PsiAnnotation.class) == null) {
result.consume(
TailTypeDecorator.withTail(
createKeyword(position, PsiKeyword.NEW), TailType.INSERT_SPACE));
result.consume(createKeyword(position, PsiKeyword.NULL));
}
if (mayExpectBoolean(parameters)) {
result.consume(createKeyword(position, PsiKeyword.TRUE));
result.consume(createKeyword(position, PsiKeyword.FALSE));
}
}
PsiFile file = position.getContainingFile();
if (!(file instanceof PsiExpressionCodeFragment)
&& !(file instanceof PsiJavaCodeReferenceCodeFragment)
&& !(file instanceof PsiTypeCodeFragment)) {
if (prevLeaf == null) {
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.PACKAGE), TailType.HUMBLE_SPACE_BEFORE_WORD));
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.IMPORT), TailType.HUMBLE_SPACE_BEFORE_WORD));
} else if (END_OF_BLOCK.getValue().isAcceptable(position, position)
&& PsiTreeUtil.getParentOfType(position, PsiMember.class) == null) {
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.IMPORT), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
}
if ((isInsideParameterList(position)
|| isAtResourceVariableStart(position)
|| isAtCatchVariableStart(position))
&& !psiElement().afterLeaf(PsiKeyword.FINAL).accepts(position)
&& !AFTER_DOT.accepts(position)) {
result.consume(
TailTypeDecorator.withTail(
createKeyword(position, PsiKeyword.FINAL), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
if (isInstanceofPlace(position)) {
result.consume(
LookupElementDecorator.withInsertHandler(
createKeyword(position, PsiKeyword.INSTANCEOF),
new InsertHandler<LookupElementDecorator<LookupElement>>() {
@Override
public void handleInsert(
InsertionContext context, LookupElementDecorator<LookupElement> item) {
TailType tailType = TailType.HUMBLE_SPACE_BEFORE_WORD;
if (tailType.isApplicable(context)) {
tailType.processTail(context.getEditor(), context.getTailOffset());
}
if ('!' == context.getCompletionChar()) {
context.setAddCompletionChar(false);
context.commitDocument();
PsiInstanceOfExpression expr =
PsiTreeUtil.findElementOfClassAtOffset(
context.getFile(),
context.getStartOffset(),
PsiInstanceOfExpression.class,
false);
if (expr != null) {
String space =
context.getCodeStyleSettings().SPACE_WITHIN_PARENTHESES ? " " : "";
context
.getDocument()
.insertString(expr.getTextRange().getStartOffset(), "!(" + space);
context.getDocument().insertString(context.getTailOffset(), space + ")");
}
}
}
}));
}
if (isSuitableForClass(position)) {
for (String s : ModifierChooser.getKeywords(position)) {
result.consume(
new OverrideableSpace(createKeyword(position, s), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.CLASS), TailType.HUMBLE_SPACE_BEFORE_WORD));
if (PsiTreeUtil.getParentOfType(position, PsiCodeBlock.class, true, PsiMember.class)
== null) {
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.INTERFACE), TailType.HUMBLE_SPACE_BEFORE_WORD));
if (PsiUtil.getLanguageLevel(position).isAtLeast(LanguageLevel.JDK_1_5)) {
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.ENUM), TailType.INSERT_SPACE));
}
}
}
addPrimitiveTypes(result, position);
if (isAfterTypeDot(position)) {
result.consume(createKeyword(position, PsiKeyword.CLASS));
}
addUnfinishedMethodTypeParameters(position, result);
if (JavaMemberNameCompletionContributor.INSIDE_TYPE_PARAMS_PATTERN.accepts(position)) {
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.EXTENDS), TailType.HUMBLE_SPACE_BEFORE_WORD));
result.consume(
new OverrideableSpace(
createKeyword(position, PsiKeyword.SUPER), TailType.HUMBLE_SPACE_BEFORE_WORD));
}
}