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;
}
@Nullable
private static PsiType getQualifierCastType(
PsiJavaReference javaReference, CompletionParameters parameters) {
if (javaReference instanceof PsiReferenceExpression) {
final PsiReferenceExpression refExpr = (PsiReferenceExpression) javaReference;
final PsiExpression qualifier = refExpr.getQualifierExpression();
if (qualifier != null) {
final Project project = qualifier.getProject();
PsiType type = null;
final PairFunction<PsiExpression, CompletionParameters, PsiType> evaluator =
refExpr.getContainingFile().getCopyableUserData(DYNAMIC_TYPE_EVALUATOR);
if (evaluator != null) {
type = evaluator.fun(qualifier, parameters);
}
if (type == null) {
type = GuessManager.getInstance(project).getControlFlowExpressionType(qualifier);
}
return type;
}
}
return null;
}
private static void reportConstantReferenceValues(
ProblemsHolder holder, StandardInstructionVisitor visitor, Set<PsiElement> reportedAnchors) {
for (Pair<PsiReferenceExpression, DfaConstValue> pair : visitor.getConstantReferenceValues()) {
PsiReferenceExpression ref = pair.first;
if (ref.getParent() instanceof PsiReferenceExpression || !reportedAnchors.add(ref)) {
continue;
}
final Object value = pair.second.getValue();
PsiVariable constant = pair.second.getConstant();
final String presentableName = constant != null ? constant.getName() : String.valueOf(value);
final String exprText = String.valueOf(value);
if (presentableName == null || exprText == null) {
continue;
}
holder.registerProblem(
ref,
"Value <code>#ref</code> #loc is always '" + presentableName + "'",
new LocalQuickFix() {
@NotNull
@Override
public String getName() {
return "Replace with '" + presentableName + "'";
}
@NotNull
@Override
public String getFamilyName() {
return "Replace with constant value";
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementsForWrite(descriptor.getPsiElement())) {
return;
}
PsiElement problemElement = descriptor.getPsiElement();
if (problemElement == null) return;
PsiMethodCallExpression call =
problemElement.getParent() instanceof PsiExpressionList
&& problemElement.getParent().getParent()
instanceof PsiMethodCallExpression
? (PsiMethodCallExpression) problemElement.getParent().getParent()
: null;
PsiMethod targetMethod = call == null ? null : call.resolveMethod();
JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
problemElement.replace(
facade.getElementFactory().createExpressionFromText(exprText, null));
if (targetMethod != null) {
ExtractMethodUtil.addCastsToEnsureResolveTarget(targetMethod, call);
}
}
});
}
}