@Override
protected String stubTreeAndIndexDoNotMatch(
StubTree stubTree,
PsiFileWithStubSupport psiFile,
List<StubElement<?>> plained,
VirtualFile virtualFile,
StubTree stubTreeFromIndex) {
String details = "Please report the problem to JetBrains with the file attached";
details += "\npsiFile" + psiFile;
details += "\npsiFile.class" + psiFile.getClass();
details += "\npsiFile.lang" + psiFile.getLanguage();
String fileText = psiFile instanceof PsiCompiledElement ? "compiled" : psiFile.getText();
return LogMessageEx.createEvent(
"PSI and index do not match",
details,
new Attachment(
virtualFile != null ? virtualFile.getPath() + "_file.txt" : "vFile.txt", fileText),
new Attachment("stubTree.txt", ((PsiFileStubImpl) stubTree.getRoot()).printTree()),
new Attachment(
"stubTreeFromIndex.txt",
stubTreeFromIndex == null
? "null"
: ((PsiFileStubImpl) stubTreeFromIndex.getRoot()).printTree()))
.toString();
}
public final void showError(@NotNull String message, @NotNull Throwable e) {
if (getProject().isDisposed()) {
return;
}
while (e instanceof InvocationTargetException) {
if (e.getCause() == null) {
break;
}
e = e.getCause();
}
ErrorInfo info = new ErrorInfo();
info.myMessage = info.myDisplayMessage = message;
info.myThrowable = e;
configureError(info);
if (info.myShowMessage) {
showErrorPage(info);
}
if (info.myShowLog) {
LOG.error(
LogMessageEx.createEvent(
info.myDisplayMessage,
info.myMessage + "\n" + ExceptionUtil.getThrowableText(info.myThrowable),
new Attachment(myFile)));
} else {
LOG.info(info.myDisplayMessage + "\n" + info.myMessage, info.myThrowable);
}
}
public static void addImportForItem(InsertionContext context, PsiClass aClass) {
if (aClass.getQualifiedName() == null) return;
PsiFile file = context.getFile();
int startOffset = context.getStartOffset();
int tail = context.getTailOffset();
int newTail = JavaCompletionUtil.insertClassReference(aClass, file, startOffset, tail);
if (newTail > context.getDocument().getTextLength() || newTail < 0) {
LOG.error(
LogMessageEx.createEvent(
"Invalid offset after insertion ",
"offset="
+ newTail
+ "\n"
+ "start="
+ startOffset
+ "\n"
+ "tail="
+ tail
+ "\n"
+ "file.length="
+ file.getTextLength()
+ "\n"
+ "document="
+ context.getDocument()
+ "\n"
+ DebugUtil.currentStackTrace(),
AttachmentFactory.createAttachment(context.getDocument())));
return;
}
context.setTailOffset(newTail);
JavaCompletionUtil.shortenReference(file, context.getStartOffset());
PostprocessReformattingAspect.getInstance(context.getProject()).doPostponedFormatting();
}
public static void assertInvalidRanges(
final int startOffset,
final int newEndOffset,
FormattingDocumentModel model,
String message) {
@NonNls final StringBuilder buffer = new StringBuilder();
buffer.append("Invalid formatting blocks:").append(message).append("\n");
buffer.append("Start offset:");
buffer.append(startOffset);
buffer.append(" end offset:");
buffer.append(newEndOffset);
buffer.append("\n");
int minOffset = Math.max(Math.min(startOffset, newEndOffset) - 20, 0);
int maxOffset = Math.min(Math.max(startOffset, newEndOffset) + 20, model.getTextLength());
buffer
.append("Affected text fragment:[")
.append(minOffset)
.append(",")
.append(maxOffset)
.append("] - '")
.append(model.getText(new TextRange(minOffset, maxOffset)))
.append("'\n");
final StringBuilder messageBuffer = new StringBuilder();
messageBuffer.append("Invalid ranges during formatting");
if (model instanceof FormattingDocumentModelImpl) {
messageBuffer
.append(" in ")
.append(((FormattingDocumentModelImpl) model).getFile().getLanguage());
}
buffer.append("File text:(").append(model.getTextLength()).append(")\n'");
buffer.append(model.getText(new TextRange(0, model.getTextLength())).toString());
buffer.append("'\n");
buffer.append("model (").append(model.getClass()).append("): ").append(model);
Throwable currentThrowable = new Throwable();
if (model instanceof FormattingDocumentModelImpl) {
final FormattingDocumentModelImpl modelImpl = (FormattingDocumentModelImpl) model;
buffer.append("Psi Tree:\n");
final PsiFile file = modelImpl.getFile();
final List<PsiFile> roots = file.getViewProvider().getAllFiles();
for (PsiFile root : roots) {
buffer.append("Root ");
DebugUtil.treeToBuffer(buffer, root.getNode(), 0, false, true, true, true);
}
buffer.append('\n');
currentThrowable = makeLanguageStackTrace(currentThrowable, file);
}
LogMessageEx.error(LOG, messageBuffer.toString(), currentThrowable, buffer.toString());
}
@Override
public void handleInsert(InsertionContext context) {
final Document document = context.getEditor().getDocument();
document.replaceString(context.getStartOffset(), context.getTailOffset(), ";");
final InsertionContext qualifierContext =
CompletionUtil.emulateInsertion(context, context.getStartOffset(), myQualifier);
OffsetKey oldStart = context.trackOffset(context.getStartOffset(), false);
int start =
CharArrayUtil.shiftForward(
context.getDocument().getCharsSequence(), context.getStartOffset(), " \t\n");
if (shouldParenthesizeQualifier(context.getFile(), start, qualifierContext.getTailOffset())) {
final String space =
CodeStyleSettingsManager.getSettings(qualifierContext.getProject())
.SPACE_WITHIN_PARENTHESES
? " "
: "";
document.insertString(start, "(" + space);
document.insertString(qualifierContext.getTailOffset(), space + ")");
}
final char atTail = document.getCharsSequence().charAt(context.getTailOffset() - 1);
if (atTail != ';') {
LOG.error(
LogMessageEx.createEvent(
"Unexpected character",
"atTail="
+ atTail
+ "\n"
+ "offset="
+ context.getTailOffset()
+ "\n"
+ "item="
+ this
+ "\n"
+ "item.class="
+ this.getClass()
+ "\n"
+ DebugUtil.currentStackTrace(),
AttachmentFactory.createAttachment(context.getDocument())));
}
document.replaceString(context.getTailOffset() - 1, context.getTailOffset(), ".");
CompletionUtil.emulateInsertion(getDelegate(), context.getTailOffset(), context);
context.commitDocument();
int formatStart = context.getOffset(oldStart);
int formatEnd = context.getTailOffset();
if (formatStart >= 0 && formatEnd >= 0) {
CodeStyleManager.getInstance(context.getProject())
.reformatText(context.getFile(), formatStart, formatEnd);
}
}
public void handleInsert(
final InsertionContext context, final JavaPsiClassReferenceElement item) {
final char c = context.getCompletionChar();
int offset = context.getTailOffset() - 1;
final PsiFile file = context.getFile();
if (PsiTreeUtil.findElementOfClassAtOffset(file, offset, PsiImportStatementBase.class, false)
!= null) {
final PsiJavaCodeReferenceElement ref =
PsiTreeUtil.findElementOfClassAtOffset(
file, offset, PsiJavaCodeReferenceElement.class, false);
final String qname = item.getQualifiedName();
if (qname != null && (ref == null || !qname.equals(ref.getCanonicalText()))) {
AllClassesGetter.INSERT_FQN.handleInsert(context, item);
}
return;
}
PsiElement position = file.findElementAt(offset);
PsiClass psiClass = item.getObject();
final Project project = context.getProject();
final boolean annotation = insertingAnnotation(context, item);
final Editor editor = context.getEditor();
if (c == '#') {
context.setLaterRunnable(
new Runnable() {
public void run() {
new CodeCompletionHandlerBase(CompletionType.BASIC).invokeCompletion(project, editor);
}
});
} else if (c == '.' && PsiTreeUtil.getParentOfType(position, PsiParameterList.class) == null) {
AutoPopupController.getInstance(context.getProject())
.autoPopupMemberLookup(context.getEditor(), null);
}
if (position != null) {
PsiElement parent = position.getParent();
if (parent instanceof PsiJavaCodeReferenceElement) {
final PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement) parent;
if (PsiTreeUtil.getParentOfType(position, PsiDocTag.class) != null
&& ref.isReferenceTo(psiClass)) {
return;
}
}
}
OffsetKey refEnd = context.trackOffset(context.getTailOffset(), false);
boolean fillTypeArgs = context.getCompletionChar() == '<';
if (fillTypeArgs) {
context.setAddCompletionChar(false);
}
if (shouldInsertParentheses(psiClass, position)) {
if (ConstructorInsertHandler.insertParentheses(context, item, psiClass, false)) {
fillTypeArgs |=
psiClass.hasTypeParameters()
&& PsiUtil.getLanguageLevel(file).isAtLeast(LanguageLevel.JDK_1_5);
}
} else if (insertingAnnotationWithParameters(context, item)) {
JavaCompletionUtil.insertParentheses(context, item, false, true);
AutoPopupController.getInstance(project).autoPopupParameterInfo(editor, null);
}
LOG.assertTrue(context.getTailOffset() >= 0);
String docText = context.getDocument().getText();
DefaultInsertHandler.addImportForItem(context, item);
if (context.getTailOffset() < 0) {
LOG.error(
LogMessageEx.createEvent(
"Tail offset degraded after insertion",
"start=" + context.getStartOffset(),
new Attachment(
context.getFile().getViewProvider().getVirtualFile().getPath(), docText)));
}
if (annotation) {
// Check if someone inserts annotation class that require @
PsiElement elementAt = file.findElementAt(context.getStartOffset());
final PsiElement parentElement = elementAt != null ? elementAt.getParent() : null;
if (elementAt instanceof PsiIdentifier
&& (PsiTreeUtil.getParentOfType(elementAt, PsiAnnotationParameterList.class) != null
|| parentElement instanceof PsiErrorElement
&& parentElement.getParent()
instanceof PsiJavaFile // top level annotation without @
)
&& isAtTokenNeeded(context)) {
int expectedOffsetForAtToken = elementAt.getTextRange().getStartOffset();
context.getDocument().insertString(expectedOffsetForAtToken, "@");
}
}
if (fillTypeArgs) {
PostprocessReformattingAspect.getInstance(project).doPostponedFormatting();
int typeArgs = context.getOffset(refEnd);
if (typeArgs >= 0) {
context.getDocument().insertString(typeArgs, "<>");
context.getEditor().getCaretModel().moveToOffset(typeArgs + 1);
}
}
}
private void error(String descr) {
PsiFile file = myScope.getContainingFile();
String fileText = file != null ? file.getText() : null;
LogMessageEx.error(LOG, descr, myScope.getText(), "\n------------------\n", fileText);
}