//static keyword in static import
{
final CompletionVariant variant = new CompletionVariant(PsiImportList.class, new LeftNeighbour(new TextFilter (PsiKeyword.IMPORT)));
- variant.addCompletion(PsiKeyword.STATIC, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.STATIC, TailType.HUMBLE_SPACE);
registerVariant(variant);
}
final CompletionVariant variant = new CompletionVariant(PsiJavaFile.class, position);
variant.includeScopeClass(PsiClass.class);
- variant.addCompletion(PsiKeyword.INTERFACE, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.INTERFACE, TailType.HUMBLE_SPACE);
registerVariant(variant);
}
final CompletionVariant variant = new CompletionVariant(PsiJavaFile.class, CLASS_START);
variant.includeScopeClass(PsiClass.class);
- variant.addCompletion(PsiKeyword.ENUM, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.ENUM, TailType.HUMBLE_SPACE);
registerVariant(variant);
}
final CompletionVariant variant = new CompletionVariant(JavaMemberNameCompletionContributor.INSIDE_TYPE_PARAMS_PATTERN);
variant.includeScopeClass(PsiVariable.class, true);
variant.includeScopeClass(PsiExpressionStatement.class, true);
- variant.addCompletion(PsiKeyword.SUPER, TailType.INSERT_SPACE);
- variant.addCompletion(PsiKeyword.EXTENDS, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.SUPER, TailType.HUMBLE_SPACE);
+ variant.addCompletion(PsiKeyword.EXTENDS, TailType.HUMBLE_SPACE);
registerVariant(variant);
}
}
if (context.shouldAddCompletionChar()) {
return;
}
- if (tailType != TailType.NONE) {
+ if (tailType != TailType.NONE && tailType.isApplicable(context)) {
tailType.processTail(context.getEditor(), context.getTailOffset());
}
}
// package keyword completion
{
final CompletionVariant variant = new CompletionVariant(PsiJavaFile.class, new StartElementFilter());
- variant.addCompletion(PsiKeyword.PACKAGE);
+ variant.addCompletion(PsiKeyword.PACKAGE, TailType.INSERT_SPACE);
registerVariant(variant);
}
// completion
final CompletionVariant variant = new CompletionVariant(position);
variant.includeScopeClass(PsiClass.class, true);
- variant.addCompletion(PsiKeyword.EXTENDS, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.EXTENDS, TailType.HUMBLE_SPACE);
variant.excludeScopeClass(PsiAnonymousClass.class);
variant.excludeScopeClass(PsiTypeParameter.class);
// completion
final CompletionVariant variant = new CompletionVariant(position);
variant.includeScopeClass(PsiClass.class, true);
- variant.addCompletion(PsiKeyword.IMPLEMENTS, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.IMPLEMENTS, TailType.HUMBLE_SPACE);
variant.excludeScopeClass(PsiAnonymousClass.class);
registerVariant(variant);
psiElement(PsiIdentifier.class).afterLeaf(
psiElement().withText(string().oneOf(",", "<")).withParent(PsiTypeParameterList.class))));
//variant.includeScopeClass(PsiClass.class, true);
- variant.addCompletion(PsiKeyword.EXTENDS, TailType.INSERT_SPACE);
+ variant.addCompletion(PsiKeyword.EXTENDS, TailType.HUMBLE_SPACE);
registerVariant(variant);
}
}
return TailType.SEMICOLON;
}
- return TailType.INSERT_SPACE;
+ return TailType.HUMBLE_SPACE;
}
scope = scope.getParent();
}
}
if (statement != null && statement.getTextRange().getStartOffset() == position.getTextRange().getStartOffset()) {
if (!psiElement().withSuperParent(2, PsiSwitchStatement.class).accepts(statement)) {
- result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.FINAL), TailType.INSERT_SPACE));
+ result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.FINAL), TailType.HUMBLE_SPACE));
}
}
}
if (INSIDE_PARAMETER_LIST.accepts(position) && !psiElement().afterLeaf(PsiKeyword.FINAL).accepts(position) && !AFTER_DOT.accepts(position)) {
- result.addElement(TailTypeDecorator.withTail(createKeyword(position, PsiKeyword.FINAL), TailType.INSERT_SPACE));
+ result.addElement(TailTypeDecorator.withTail(createKeyword(position, PsiKeyword.FINAL), TailType.HUMBLE_SPACE));
}
if (CLASS_START.isAcceptable(position, position) &&
PsiTreeUtil.getNonStrictParentOfType(position, PsiLiteralExpression.class, PsiComment.class) == null) {
for (String s : ModifierChooser.getKeywords(position)) {
- result.addElement(new OverrideableSpace(createKeyword(position, s), TailType.INSERT_SPACE));
+ result.addElement(new OverrideableSpace(createKeyword(position, s), TailType.HUMBLE_SPACE));
}
}
isStatementPosition(position)) {
for (String primitiveType : PRIMITIVE_TYPES) {
LookupElement keyword = createKeyword(position, primitiveType);
- result.addElement(inCast ? keyword : new OverrideableSpace(keyword, TailType.INSERT_SPACE));
+ result.addElement(inCast ? keyword : new OverrideableSpace(keyword, TailType.HUMBLE_SPACE));
}
}
if (declaration) {
- result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.VOID), TailType.INSERT_SPACE));
+ result.addElement(new OverrideableSpace(createKeyword(position, PsiKeyword.VOID), TailType.HUMBLE_SPACE));
}
}
for (PsiClassType ref : method.getThrowsList().getReferencedTypes()) {
final PsiClass exception = ref.resolve();
if (exception != null && throwsSet.add(exception)) {
- result.addElement(TailTypeDecorator.withTail(new JavaPsiClassReferenceElement(exception), TailType.INSERT_SPACE));
+ result.addElement(TailTypeDecorator.withTail(new JavaPsiClassReferenceElement(exception), TailType.HUMBLE_SPACE));
}
}
}
if (tryBlock == null) return;
for (final PsiClassType type : ExceptionUtil.getThrownExceptions(tryBlock.getStatements())) {
- result.addElement(TailTypeDecorator.withTail(PsiTypeLookupItem.createLookupItem(type, tryBlock).setInsertHandler(new DefaultInsertHandler()), TailType.INSERT_SPACE));
+ result.addElement(TailTypeDecorator.withTail(PsiTypeLookupItem.createLookupItem(type, tryBlock).setInsertHandler(new DefaultInsertHandler()), TailType.HUMBLE_SPACE));
}
}
});
-class Foo<T extends <caret> A> {
+class Foo<T extends<caret> A> {
}
class AAA{}
-class BBB extends AAA implements <caret> {
+class BBB extends AAA implements<caret> {
}
public class A{
- public void method(final <caret> String){
+ public void method(final<caret> String){
}
}
class A {
- private long <caret> localizedStringManager;
+ private long<caret> localizedStringManager;
}
return "COMMA";
}
};
+ /**
+ * insert a space, overtype if already present
+ */
public static final TailType SPACE = new CharTailType(' ');
+ /**
+ * always insert a space
+ */
public static final TailType INSERT_SPACE = new CharTailType(' ', false);
+ /**
+ * insert a space unless there's one at the caret position already
+ */
+ public static final TailType HUMBLE_SPACE = new CharTailType(' ', false) {
+
+ @Override
+ public boolean isApplicable(@NotNull InsertionContext context) {
+ CharSequence text = context.getDocument().getCharsSequence();
+ if (text.length() > context.getTailOffset() && text.charAt(context.getTailOffset()) == ' ') {
+ return false;
+ }
+ return super.isApplicable(context);
+ }
+
+ @Override
+ public String toString() {
+ return "HUMBLE_SPACE";
+ }
+ };
public static final TailType DOT = new CharTailType('.');
public static final TailType CASE_COLON = new CharTailType(':');
addTypeDefinitionKeywords(result, position);
for (String keyword : addExtendsImplements(position)) {
- result.addElement(keyword(keyword, TailType.INSERT_SPACE));
+ result.addElement(keyword(keyword, TailType.HUMBLE_SPACE));
}
registerControlCompletion(position, result);
if (parent instanceof GrExpression) {
- addKeywords(result, false, PsiKeyword.TRUE, PsiKeyword.FALSE, PsiKeyword.NULL, PsiKeyword.SUPER, PsiKeyword.NEW, PsiKeyword.THIS, "as");
+ addKeywords(result, false, PsiKeyword.TRUE, PsiKeyword.FALSE, PsiKeyword.NULL, PsiKeyword.SUPER, PsiKeyword.THIS);
+ result.addElement(keyword(PsiKeyword.NEW, TailType.INSERT_SPACE));
+ result.addElement(keyword("as", TailType.HUMBLE_SPACE));
}
if (isInfixOperatorPosition(position)) {
addKeywords(result, true, "in", PsiKeyword.INSTANCEOF);
} else if (suggestThrows(position)) {
- addKeywords(result, true, PsiKeyword.THROWS);
+ result.addElement(keyword(PsiKeyword.THROWS, TailType.INSERT_SPACE));
} else if (suggestPrimitiveTypes(position)) {
boolean inCast = psiElement()
.afterLeaf(psiElement().withText("(").withParent(psiElement(GrParenthesizedExpression.class, GrTypeCastExpression.class)))
addKeywords(result, true, PsiKeyword.CLASS, PsiKeyword.INTERFACE, PsiKeyword.ENUM);
}
if (afterAtInType(position)) {
- result.addElement(keyword(PsiKeyword.INTERFACE, TailType.INSERT_SPACE));
+ result.addElement(keyword(PsiKeyword.INTERFACE, TailType.HUMBLE_SPACE));
}
}
public static void addKeywords(CompletionResultSet result, boolean space, String... keywords) {
for (String s : keywords) {
- result.addElement(keyword(s, space ? TailType.INSERT_SPACE : TailType.NONE));
+ result.addElement(keyword(s, space ? TailType.HUMBLE_SPACE : TailType.NONE));
}
}
}
public void testInnerClassStart() {
- checkSingleItemCompletion 'class Foo { cl<caret> }', 'class Foo { class <caret> }'
+ checkSingleItemCompletion 'class Foo { cl<caret> }', 'class Foo { class<caret> }'
}
public void testPropertyBeforeAccessor() {
public void testSpaceTail() {
checkCompletion 'class A <caret> ArrayList {}', ' ', 'class A extends <caret> ArrayList {}'
- checkCompletion 'class A <caret> ArrayList {}', '\n', 'class A extends <caret> ArrayList {}'
- checkSingleItemCompletion 'class Foo impl<caret> {}', 'class Foo implements <caret> {}'
+ checkCompletion 'class A <caret> ArrayList {}', '\n', 'class A extends<caret> ArrayList {}'
+ checkSingleItemCompletion 'class Foo impl<caret> {}', 'class Foo implements<caret> {}'
}
public void testPreferInterfacesInImplements() {