private void replaceCollectionGetAccess(
PsiElement element,
String contentVariableName,
PsiVariable listVariable,
String indexName,
PsiElement childToSkip,
StringBuilder out) {
if (isListGetLookup(element, indexName, listVariable)) {
out.append(contentVariableName);
} else {
final PsiElement[] children = element.getChildren();
if (children.length == 0) {
final String text = element.getText();
if (PsiKeyword.INSTANCEOF.equals(text) && out.charAt(out.length() - 1) != ' ') {
out.append(' ');
}
out.append(text);
} else {
boolean skippingWhiteSpace = false;
for (final PsiElement child : children) {
if (child.equals(childToSkip)) {
skippingWhiteSpace = true;
} else if (child instanceof PsiWhiteSpace && skippingWhiteSpace) {
// don't do anything
} else {
skippingWhiteSpace = false;
replaceCollectionGetAccess(
child, contentVariableName, listVariable, indexName, childToSkip, out);
}
}
}
}
}
private void replaceIteratorNext(
PsiElement element,
String contentVariableName,
String iteratorName,
PsiElement childToSkip,
StringBuilder out,
PsiType contentType) {
if (isIteratorNext(element, iteratorName, contentType)) {
out.append(contentVariableName);
} else {
final PsiElement[] children = element.getChildren();
if (children.length == 0) {
final String text = element.getText();
if (PsiKeyword.INSTANCEOF.equals(text) && out.charAt(out.length() - 1) != ' ') {
out.append(' ');
}
out.append(text);
} else {
boolean skippingWhiteSpace = false;
for (final PsiElement child : children) {
if (child.equals(childToSkip)) {
skippingWhiteSpace = true;
} else if (child instanceof PsiWhiteSpace && skippingWhiteSpace) {
// don't do anything
} else {
skippingWhiteSpace = false;
replaceIteratorNext(
child, contentVariableName, iteratorName, childToSkip, out, contentType);
}
}
}
}
}
@Override
@Nullable
public Collection<PsiImportStatementBase> findRedundantImports(final PsiJavaFile file) {
final PsiImportList importList = file.getImportList();
if (importList == null) return null;
final PsiImportStatementBase[] imports = importList.getAllImportStatements();
if (imports.length == 0) return null;
Set<PsiImportStatementBase> allImports =
new THashSet<PsiImportStatementBase>(Arrays.asList(imports));
final Collection<PsiImportStatementBase> redundant;
if (FileTypeUtils.isInServerPageFile(file)) {
// remove only duplicate imports
redundant = ContainerUtil.newIdentityTroveSet();
ContainerUtil.addAll(redundant, imports);
redundant.removeAll(allImports);
for (PsiImportStatementBase importStatement : imports) {
if (importStatement instanceof JspxImportStatement
&& importStatement.isForeignFileImport()) {
redundant.remove(importStatement);
}
}
} else {
redundant = allImports;
final List<PsiFile> roots = file.getViewProvider().getAllFiles();
for (PsiElement root : roots) {
root.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
if (!reference.isQualified()) {
final JavaResolveResult resolveResult = reference.advancedResolve(false);
if (!inTheSamePackage(file, resolveResult.getElement())) {
final PsiElement resolveScope = resolveResult.getCurrentFileResolveScope();
if (resolveScope instanceof PsiImportStatementBase) {
final PsiImportStatementBase importStatementBase =
(PsiImportStatementBase) resolveScope;
redundant.remove(importStatementBase);
}
}
}
super.visitReferenceElement(reference);
}
private boolean inTheSamePackage(PsiJavaFile file, PsiElement element) {
if (element instanceof PsiClass
&& ((PsiClass) element).getContainingClass() == null) {
final PsiFile containingFile = element.getContainingFile();
if (containingFile instanceof PsiJavaFile) {
return Comparing.strEqual(
file.getPackageName(), ((PsiJavaFile) containingFile).getPackageName());
}
}
return false;
}
});
}
}
return redundant;
}
public static void initOffsets(final PsiFile file, final OffsetMap offsetMap) {
int offset =
Math.max(
offsetMap.getOffset(CompletionInitializationContext.SELECTION_END_OFFSET),
offsetMap.getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET));
PsiElement element = file.findElementAt(offset);
if (element instanceof PsiWhiteSpace
&& (!element.textContains('\n')
|| CodeStyleSettingsManager.getSettings(file.getProject())
.getCommonSettings(JavaLanguage.INSTANCE)
.METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE)) {
element = file.findElementAt(element.getTextRange().getEndOffset());
}
if (element == null) return;
if (LEFT_PAREN.accepts(element)) {
offsetMap.addOffset(LPAREN_OFFSET, element.getTextRange().getStartOffset());
PsiElement list = element.getParent();
PsiElement last = list.getLastChild();
if (last instanceof PsiJavaToken
&& ((PsiJavaToken) last).getTokenType() == JavaTokenType.RPARENTH) {
offsetMap.addOffset(RPAREN_OFFSET, last.getTextRange().getStartOffset());
}
offsetMap.addOffset(ARG_LIST_END_OFFSET, list.getTextRange().getEndOffset());
}
}
@Override
public void doFix(Project project, ProblemDescriptor descriptor)
throws IncorrectOperationException {
final PsiElement forElement = descriptor.getPsiElement();
final PsiElement parent = forElement.getParent();
if (!(parent instanceof PsiForStatement)) {
return;
}
final PsiForStatement forStatement = (PsiForStatement)parent;
final String newExpression;
if (isArrayLoopStatement(forStatement)) {
newExpression = createArrayIterationText(forStatement);
}
else if (isCollectionLoopStatement(forStatement, ignoreUntypedCollections)) {
newExpression = createCollectionIterationText(forStatement);
}
else if (isIndexedListLoopStatement(forStatement, ignoreUntypedCollections)) {
newExpression = createListIterationText(forStatement);
}
else {
return;
}
if (newExpression == null) {
return;
}
replaceStatementAndShortenClassNames(forStatement, newExpression);
}
@Override
public PsiElement qualifyClassReferences(@NotNull PsiElement element) {
final ReferenceAdjuster adjuster =
ReferenceAdjuster.Extension.getReferenceAdjuster(element.getLanguage());
if (adjuster != null) {
final ASTNode reference = adjuster.process(element.getNode(), false, false, true, true);
return SourceTreeToPsiMap.treeToPsiNotNull(reference);
}
return element;
}
@Override
public void shortenClassReferences(@NotNull PsiElement element, int startOffset, int endOffset)
throws IncorrectOperationException {
CheckUtil.checkWritable(element);
if (SourceTreeToPsiMap.hasTreeElement(element)) {
final ReferenceAdjuster adjuster =
ReferenceAdjuster.Extension.getReferenceAdjuster(element.getLanguage());
if (adjuster != null) {
adjuster.processRange(element.getNode(), startOffset, endOffset, myProject);
}
}
}
public static boolean isStringPsiLiteral(PsiElement element) {
if (element instanceof PsiLiteralExpression) {
final String text = element.getText();
return StringUtil.isQuotedString(text);
}
return false;
}
@Override
public String suggestUniqueVariableName(String baseName, PsiElement place, boolean lookForward) {
int index = 0;
PsiElement scope =
PsiTreeUtil.getNonStrictParentOfType(
place, PsiStatement.class, PsiCodeBlock.class, PsiMethod.class);
NextName:
while (true) {
String name = baseName;
if (index > 0) {
name += index;
}
index++;
if (PsiUtil.isVariableNameUnique(name, place)) {
if (lookForward) {
final String name1 = name;
PsiElement run = scope;
while (run != null) {
class CancelException extends RuntimeException {}
try {
run.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitAnonymousClass(final PsiAnonymousClass aClass) {}
@Override
public void visitVariable(PsiVariable variable) {
if (name1.equals(variable.getName())) {
throw new CancelException();
}
}
});
} catch (CancelException e) {
continue NextName;
}
run = run.getNextSibling();
if (scope instanceof PsiMethod) { // do not check next member for param name conflict
break;
}
}
}
return name;
}
}
}
@Override
public PsiElement shortenClassReferences(@NotNull PsiElement element, int flags)
throws IncorrectOperationException {
CheckUtil.checkWritable(element);
if (!SourceTreeToPsiMap.hasTreeElement(element)) return element;
final boolean addImports = (flags & DO_NOT_ADD_IMPORTS) == 0;
final boolean incompleteCode = (flags & UNCOMPLETE_CODE) != 0;
final ReferenceAdjuster adjuster =
ReferenceAdjuster.Extension.getReferenceAdjuster(element.getLanguage());
if (adjuster != null) {
final ASTNode reference =
adjuster.process(element.getNode(), addImports, incompleteCode, myProject);
return SourceTreeToPsiMap.treeToPsiNotNull(reference);
} else {
return element;
}
}
public static boolean insertTail(
InsertionContext context, LookupElement item, TailType tailType, boolean hasTail) {
TailType toInsert = tailType;
LookupItem<?> lookupItem = item.as(LookupItem.CLASS_CONDITION_KEY);
if (lookupItem == null
|| lookupItem.getAttribute(LookupItem.TAIL_TYPE_ATTR) != TailType.UNKNOWN) {
if (!hasTail
&& item.getObject() instanceof PsiMethod
&& ((PsiMethod) item.getObject()).getReturnType() == PsiType.VOID) {
PsiDocumentManager.getInstance(context.getProject()).commitAllDocuments();
if (psiElement()
.beforeLeaf(psiElement().withText("."))
.accepts(context.getFile().findElementAt(context.getTailOffset() - 1))) {
return false;
}
boolean insertAdditionalSemicolon = true;
final PsiReferenceExpression referenceExpression =
PsiTreeUtil.getTopmostParentOfType(
context.getFile().findElementAt(context.getStartOffset()),
PsiReferenceExpression.class);
if (referenceExpression instanceof PsiMethodReferenceExpression
&& LambdaHighlightingUtil.insertSemicolon(referenceExpression.getParent())) {
insertAdditionalSemicolon = false;
} else if (referenceExpression != null) {
PsiElement parent = referenceExpression.getParent();
if (parent instanceof PsiMethodCallExpression) {
parent = parent.getParent();
}
if (parent instanceof PsiLambdaExpression
&& !LambdaHighlightingUtil.insertSemicolonAfter((PsiLambdaExpression) parent)) {
insertAdditionalSemicolon = false;
}
}
if (insertAdditionalSemicolon) {
toInsert = TailType.SEMICOLON;
}
}
}
toInsert.processTail(context.getEditor(), context.getTailOffset());
return true;
}
private NamesByExprInfo suggestVariableNameByExpressionPlace(
PsiExpression expr, final VariableKind variableKind, boolean correctKeywords) {
if (expr.getParent() instanceof PsiExpressionList) {
PsiExpressionList list = (PsiExpressionList) expr.getParent();
PsiElement listParent = list.getParent();
PsiSubstitutor subst = PsiSubstitutor.EMPTY;
PsiMethod method = null;
if (listParent instanceof PsiMethodCallExpression) {
final JavaResolveResult resolveResult =
((PsiMethodCallExpression) listParent).getMethodExpression().advancedResolve(false);
method = (PsiMethod) resolveResult.getElement();
subst = resolveResult.getSubstitutor();
} else {
if (listParent instanceof PsiAnonymousClass) {
listParent = listParent.getParent();
}
if (listParent instanceof PsiNewExpression) {
method = ((PsiNewExpression) listParent).resolveConstructor();
}
}
if (method != null) {
final PsiElement navElement = method.getNavigationElement();
if (navElement instanceof PsiMethod) {
method = (PsiMethod) navElement;
}
PsiExpression[] expressions = list.getExpressions();
int index = -1;
for (int i = 0; i < expressions.length; i++) {
if (expressions[i] == expr) {
index = i;
break;
}
}
PsiParameter[] parameters = method.getParameterList().getParameters();
if (index < parameters.length) {
String name = parameters[index].getName();
if (name != null
&& TypeConversionUtil.areTypesAssignmentCompatible(
subst.substitute(parameters[index].getType()), expr)) {
name = variableNameToPropertyName(name, VariableKind.PARAMETER);
String[] names = getSuggestionsByName(name, variableKind, false, correctKeywords);
if (expressions.length == 1) {
final String methodName = method.getName();
String[] words = NameUtil.nameToWords(methodName);
if (words.length > 0) {
final String firstWord = words[0];
if (SET_PREFIX.equals(firstWord)) {
final String propertyName = methodName.substring(firstWord.length());
final String[] setterNames =
getSuggestionsByName(propertyName, variableKind, false, correctKeywords);
names = ArrayUtil.mergeArrays(names, setterNames);
}
}
}
return new NamesByExprInfo(name, names);
}
}
}
} else if (expr.getParent() instanceof PsiAssignmentExpression
&& variableKind == VariableKind.PARAMETER) {
final PsiAssignmentExpression assignmentExpression =
(PsiAssignmentExpression) expr.getParent();
if (expr == assignmentExpression.getRExpression()) {
final PsiExpression leftExpression = assignmentExpression.getLExpression();
if (leftExpression instanceof PsiReferenceExpression
&& ((PsiReferenceExpression) leftExpression).getQualifier() == null) {
String name = leftExpression.getText();
if (name != null) {
final PsiElement resolve = ((PsiReferenceExpression) leftExpression).resolve();
if (resolve instanceof PsiVariable) {
name = variableNameToPropertyName(name, getVariableKind((PsiVariable) resolve));
}
String[] names = getSuggestionsByName(name, variableKind, false, correctKeywords);
return new NamesByExprInfo(name, names);
}
}
}
}
return new NamesByExprInfo(null, ArrayUtil.EMPTY_STRING_ARRAY);
}
public static boolean inSomePackage(PsiElement context) {
PsiFile contextFile = context.getContainingFile();
return contextFile instanceof PsiClassOwner
&& StringUtil.isNotEmpty(((PsiClassOwner) contextFile).getPackageName());
}
public static void insertParentheses(
final InsertionContext context,
final LookupElement item,
boolean overloadsMatter,
boolean hasParams,
final boolean forceClosingParenthesis) {
final Editor editor = context.getEditor();
final char completionChar = context.getCompletionChar();
final PsiFile file = context.getFile();
final TailType tailType =
completionChar == '('
? TailType.NONE
: completionChar == ':'
? TailType.COND_EXPR_COLON
: LookupItem.handleCompletionChar(context.getEditor(), item, completionChar);
final boolean hasTail = tailType != TailType.NONE && tailType != TailType.UNKNOWN;
final boolean smart = completionChar == Lookup.COMPLETE_STATEMENT_SELECT_CHAR;
if (completionChar == '('
|| completionChar == '.'
|| completionChar == ','
|| completionChar == ';'
|| completionChar == ':'
|| completionChar == ' ') {
context.setAddCompletionChar(false);
}
if (hasTail) {
hasParams = false;
}
final boolean needRightParenth =
forceClosingParenthesis
|| !smart
&& (CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET
|| !hasParams && completionChar != '(');
context.commitDocument();
final CommonCodeStyleSettings styleSettings = context.getCodeStyleSettings();
final PsiElement elementAt = file.findElementAt(context.getStartOffset());
if (elementAt == null || !(elementAt.getParent() instanceof PsiMethodReferenceExpression)) {
ParenthesesInsertHandler.getInstance(
hasParams,
styleSettings.SPACE_BEFORE_METHOD_CALL_PARENTHESES,
styleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES && hasParams,
needRightParenth,
styleSettings.METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE)
.handleInsert(context, item);
}
if (hasParams) {
// Invoke parameters popup
AutoPopupController.getInstance(file.getProject())
.autoPopupParameterInfo(editor, overloadsMatter ? null : (PsiElement) item.getObject());
}
if (smart || !needRightParenth || !insertTail(context, item, tailType, hasTail)) {
return;
}
if (completionChar == '.') {
AutoPopupController.getInstance(file.getProject())
.autoPopupMemberLookup(context.getEditor(), null);
} else if (completionChar == ',') {
AutoPopupController.getInstance(file.getProject())
.autoPopupParameterInfo(context.getEditor(), null);
}
}
public static int insertClassReference(
PsiClass psiClass, PsiFile file, int startOffset, int endOffset) {
final Project project = file.getProject();
PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
documentManager.commitAllDocuments();
final PsiManager manager = file.getManager();
final Document document =
FileDocumentManager.getInstance().getDocument(file.getViewProvider().getVirtualFile());
final PsiReference reference = file.findReferenceAt(startOffset);
if (reference != null) {
final PsiElement resolved = reference.resolve();
if (resolved instanceof PsiClass) {
if (((PsiClass) resolved).getQualifiedName() == null
|| manager.areElementsEquivalent(psiClass, resolved)) {
return endOffset;
}
}
}
String name = psiClass.getName();
if (name == null) {
return endOffset;
}
assert document != null;
document.replaceString(startOffset, endOffset, name);
int newEndOffset = startOffset + name.length();
final RangeMarker toDelete = insertTemporary(newEndOffset, document, " ");
documentManager.commitAllDocuments();
PsiElement element = file.findElementAt(startOffset);
if (element instanceof PsiIdentifier) {
PsiElement parent = element.getParent();
if (parent instanceof PsiJavaCodeReferenceElement
&& !((PsiJavaCodeReferenceElement) parent).isQualified()
&& !(parent.getParent() instanceof PsiPackageStatement)) {
PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement) parent;
if (psiClass.isValid()
&& !psiClass.getManager().areElementsEquivalent(psiClass, resolveReference(ref))) {
final boolean staticImport = ref instanceof PsiImportStaticReferenceElement;
PsiElement newElement;
try {
newElement =
staticImport
? ((PsiImportStaticReferenceElement) ref).bindToTargetClass(psiClass)
: ref.bindToElement(psiClass);
} catch (IncorrectOperationException e) {
return endOffset; // can happen if fqn contains reserved words, for example
}
final RangeMarker rangeMarker = document.createRangeMarker(newElement.getTextRange());
documentManager.doPostponedOperationsAndUnblockDocument(document);
documentManager.commitDocument(document);
newElement =
CodeInsightUtilCore.findElementInRange(
file,
rangeMarker.getStartOffset(),
rangeMarker.getEndOffset(),
PsiJavaCodeReferenceElement.class,
JavaLanguage.INSTANCE);
rangeMarker.dispose();
if (newElement != null) {
newEndOffset = newElement.getTextRange().getEndOffset();
if (!(newElement instanceof PsiReferenceExpression)) {
PsiReferenceParameterList parameterList =
((PsiJavaCodeReferenceElement) newElement).getParameterList();
if (parameterList != null) {
newEndOffset = parameterList.getTextRange().getStartOffset();
}
}
if (!staticImport
&& !psiClass
.getManager()
.areElementsEquivalent(psiClass, resolveReference((PsiReference) newElement))
&& !PsiUtil.isInnerClass(psiClass)) {
final String qName = psiClass.getQualifiedName();
if (qName != null) {
document.replaceString(
newElement.getTextRange().getStartOffset(), newEndOffset, qName);
newEndOffset = newElement.getTextRange().getStartOffset() + qName.length();
}
}
}
}
}
}
if (toDelete.isValid()) {
document.deleteString(toDelete.getStartOffset(), toDelete.getEndOffset());
}
return newEndOffset;
}
public static Set<LookupElement> processJavaReference(
PsiElement element,
PsiJavaReference javaReference,
ElementFilter elementFilter,
JavaCompletionProcessor.Options options,
final PrefixMatcher matcher,
CompletionParameters parameters) {
final Set<LookupElement> set = new LinkedHashSet<LookupElement>();
final Condition<String> nameCondition =
new Condition<String>() {
@Override
public boolean value(String s) {
return matcher.prefixMatches(s);
}
};
PsiMethodCallExpression call =
PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
boolean checkInitialized =
parameters.getInvocationCount() <= 1
&& call != null
&& PsiKeyword.SUPER.equals(call.getMethodExpression().getText());
final JavaCompletionProcessor processor =
new JavaCompletionProcessor(
element, elementFilter, options.withInitialized(checkInitialized), nameCondition);
final PsiType plainQualifier = processor.getQualifierType();
PsiType qualifierType = plainQualifier;
PsiType runtimeQualifier = getQualifierCastType(javaReference, parameters);
if (runtimeQualifier != null) {
PsiType composite =
qualifierType == null
? runtimeQualifier
: PsiIntersectionType.createIntersection(qualifierType, runtimeQualifier);
PsiElement ctx = createContextWithXxxVariable(element, composite);
javaReference =
(PsiReferenceExpression)
JavaPsiFacade.getElementFactory(element.getProject())
.createExpressionFromText("xxx.xxx", ctx);
qualifierType = runtimeQualifier;
processor.setQualifierType(qualifierType);
}
javaReference.processVariants(processor);
final PsiTypeLookupItem castItem =
runtimeQualifier == null
? null
: PsiTypeLookupItem.createLookupItem(
runtimeQualifier, (PsiReferenceExpression) javaReference);
final boolean pkgContext = inSomePackage(element);
final Set<PsiMember> mentioned = new THashSet<PsiMember>();
for (CompletionElement completionElement : processor.getResults()) {
for (LookupElement item : createLookupElements(completionElement, javaReference)) {
item.putUserData(QUALIFIER_TYPE_ATTR, qualifierType);
final Object o = item.getObject();
if (o instanceof PsiClass && !isSourceLevelAccessible(element, (PsiClass) o, pkgContext)) {
continue;
}
if (o instanceof PsiMember) {
if (isInExcludedPackage((PsiMember) o, true)) {
continue;
}
mentioned.add(CompletionUtil.getOriginalOrSelf((PsiMember) o));
}
set.add(
highlightIfNeeded(
qualifierType,
castQualifier(item, castItem, plainQualifier, processor),
o,
element));
}
}
if (javaReference instanceof PsiJavaCodeReferenceElement
&& !((PsiJavaCodeReferenceElement) javaReference).isQualified()) {
final StaticMemberProcessor memberProcessor = new JavaStaticMemberProcessor(parameters);
memberProcessor.processMembersOfRegisteredClasses(
matcher,
new PairConsumer<PsiMember, PsiClass>() {
@Override
public void consume(PsiMember member, PsiClass psiClass) {
if (!mentioned.contains(member)
&& processor.satisfies(member, ResolveState.initial())) {
set.add(memberProcessor.createLookupElement(member, psiClass, true));
}
}
});
}
return set;
}
