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());
}
}
public static void handleError(
SAXParseException ex, PsiFile file, Document document, ValidationMessageConsumer consumer) {
final String systemId = ex.getSystemId();
if (LOG.isDebugEnabled()) {
LOG.debug("RNG Schema error: " + ex.getMessage() + " [" + systemId + "]");
}
if (systemId != null) {
final VirtualFile virtualFile = findVirtualFile(systemId);
if (!Comparing.equal(virtualFile, file.getVirtualFile())) {
return;
}
}
final PsiElement at;
final int line = ex.getLineNumber();
if (line > 0) {
final int column = ex.getColumnNumber();
final int startOffset = document.getLineStartOffset(line - 1);
if (column > 0) {
if (file.getFileType() == RncFileType.getInstance()) {
final PsiElement e = file.findElementAt(startOffset + column);
if (e == null) {
at = e;
} else {
at = file.findElementAt(startOffset + column - 1);
}
} else {
at = file.findElementAt(startOffset + column - 2);
}
} else {
final PsiElement e = file.findElementAt(startOffset);
at = e != null ? PsiTreeUtil.nextLeaf(e) : null;
}
} else {
final XmlDocument d = ((XmlFile) file).getDocument();
assert d != null;
final XmlTag rootTag = d.getRootTag();
assert rootTag != null;
at = rootTag.getFirstChild();
}
final PsiElement host;
if (file instanceof RncFile) {
host = at;
} else {
host = PsiTreeUtil.getParentOfType(at, XmlAttribute.class, XmlTag.class);
}
if (at != null && host != null) {
consumer.onMessage(host, ex.getMessage());
} else {
consumer.onMessage(file, ex.getMessage());
}
}
@Nullable
private PsiComment createComment(final CharSequence buffer, final CodeInsightSettings settings)
throws IncorrectOperationException {
myDocument.insertString(myOffset, buffer);
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
CodeStyleManager.getInstance(getProject())
.adjustLineIndent(myFile, myOffset + buffer.length() - 2);
PsiComment comment =
PsiTreeUtil.getNonStrictParentOfType(myFile.findElementAt(myOffset), PsiComment.class);
comment = createJavaDocStub(settings, comment, getProject());
if (comment == null) {
return null;
}
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(getProject());
CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(getProject());
boolean old = codeStyleSettings.ENABLE_JAVADOC_FORMATTING;
codeStyleSettings.ENABLE_JAVADOC_FORMATTING = false;
try {
comment = (PsiComment) codeStyleManager.reformat(comment);
} finally {
codeStyleSettings.ENABLE_JAVADOC_FORMATTING = old;
}
PsiElement next = comment.getNextSibling();
if (next == null && comment.getParent().getClass() == comment.getClass()) {
next =
comment
.getParent()
.getNextSibling(); // expanding chameleon comment produces comment under comment
}
if (next != null) {
next =
myFile.findElementAt(
next.getTextRange().getStartOffset()); // maybe switch to another tree
}
if (next != null
&& (!FormatterUtil.containsWhiteSpacesOnly(next.getNode())
|| !next.getText().contains(LINE_SEPARATOR))) {
int lineBreakOffset = comment.getTextRange().getEndOffset();
myDocument.insertString(lineBreakOffset, LINE_SEPARATOR);
PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
codeStyleManager.adjustLineIndent(myFile, lineBreakOffset + 1);
comment =
PsiTreeUtil.getNonStrictParentOfType(myFile.findElementAt(myOffset), PsiComment.class);
}
return comment;
}
private static boolean navigateInCurrentEditor(
@NotNull PsiElement element, @NotNull PsiFile currentFile, @NotNull Editor currentEditor) {
if (element.getContainingFile() == currentFile) {
int offset = element.getTextOffset();
PsiElement leaf = currentFile.findElementAt(offset);
// check that element is really physically inside the file
// there are fake elements with custom navigation (e.g. opening URL in browser) that override
// getContainingFile for various reasons
if (leaf != null && PsiTreeUtil.isAncestor(element, leaf, false)) {
Project project = element.getProject();
CommandProcessor.getInstance()
.executeCommand(
project,
() -> {
IdeDocumentHistory.getInstance(project).includeCurrentCommandAsNavigation();
new OpenFileDescriptor(
project, currentFile.getViewProvider().getVirtualFile(), offset)
.navigateIn(currentEditor);
},
"",
null);
return true;
}
}
return false;
}
public void invoke(
@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
int offset = editor.getCaretModel().getOffset();
editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
PsiElement element = file.findElementAt(offset);
while (true) {
if (element == null || element instanceof PsiFile) {
String message =
RefactoringBundle.getCannotRefactorMessage(
RefactoringBundle.message(
"the.caret.should.be.positioned.inside.a.class.to.push.members.from"));
CommonRefactoringUtil.showErrorHint(
project, editor, message, REFACTORING_NAME, HelpID.MEMBERS_PUSH_DOWN);
return;
}
if (element instanceof PsiClass
|| element instanceof PsiField
|| element instanceof PsiMethod) {
if (element instanceof JspClass) {
RefactoringMessageUtil.showNotSupportedForJspClassesError(
project, editor, REFACTORING_NAME, HelpID.MEMBERS_PUSH_DOWN);
return;
}
invoke(project, new PsiElement[] {element}, dataContext);
return;
}
element = element.getParent();
}
}
public void invoke(
@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
final int offset =
TargetElementUtil.adjustOffset(
file, editor.getDocument(), editor.getCaretModel().getOffset());
final PsiElement element = file.findElementAt(offset);
PsiTypeElement typeElement = PsiTreeUtil.getParentOfType(element, PsiTypeElement.class);
while (typeElement != null) {
final PsiElement parent = typeElement.getParent();
PsiElement[] toMigrate = null;
if (parent instanceof PsiVariable) {
toMigrate = extractReferencedVariables(typeElement);
} else if ((parent instanceof PsiMember && !(parent instanceof PsiClass))
|| isClassArgument(parent)) {
toMigrate = new PsiElement[] {parent};
}
if (toMigrate != null && toMigrate.length > 0) {
invoke(project, toMigrate, null, null, editor);
return;
}
typeElement = PsiTreeUtil.getParentOfType(parent, PsiTypeElement.class, false);
}
CommonRefactoringUtil.showErrorHint(
project,
editor,
"The caret should be positioned on type of field, variable, method or method parameter to be refactored",
REFACTORING_NAME,
"refactoring.migrateType");
}
public PsiFile resolve() {
final PsiFile referencedFile = getReferencedFile();
if (referencedFile != null) {
return referencedFile;
}
if (myPsiFile != null) {
final PsiElement psiElement = myPsiFile.findElementAt(myLinkInfo.offset);
if (psiElement != null) {
final PsiElement parent = psiElement.getParent();
if (parent instanceof XmlTag) {
final XmlAttribute attribute = ((XmlTag) parent).getAttribute(HREF_ATTR);
if (attribute != null) {
final XmlAttributeValue value = attribute.getValueElement();
if (value != null) {
final PsiReference[] references = value.getReferences();
for (PsiReference reference : references) {
final PsiElement element = reference.resolve();
if (element instanceof PsiFile) {
return (PsiFile) element;
}
}
}
}
}
}
}
return null;
}
protected boolean shouldParenthesizeQualifier(
final PsiFile file, final int startOffset, final int endOffset) {
PsiElement element = file.findElementAt(startOffset);
if (element == null) {
return false;
}
PsiElement last = element;
while (element != null
&& element.getTextRange().getStartOffset() >= startOffset
&& element.getTextRange().getEndOffset() <= endOffset
&& !(element instanceof PsiExpressionStatement)) {
last = element;
element = element.getParent();
}
PsiExpression expr =
PsiTreeUtil.getParentOfType(last, PsiExpression.class, false, PsiClass.class);
if (expr == null) {
return false;
}
if (expr.getTextRange().getEndOffset() > endOffset) {
return true;
}
if (expr instanceof PsiJavaCodeReferenceElement
|| expr instanceof PsiMethodCallExpression
|| expr instanceof PsiArrayAccessExpression) {
return false;
}
return true;
}
protected void moveCaretInsideBracesIfAny(
@NotNull final Editor editor, @NotNull final PsiFile file)
throws IncorrectOperationException {
int caretOffset = editor.getCaretModel().getOffset();
final CharSequence chars = editor.getDocument().getCharsSequence();
if (CharArrayUtil.regionMatches(chars, caretOffset, "{}")) {
caretOffset += 2;
} else if (CharArrayUtil.regionMatches(chars, caretOffset, "{\n}")) {
caretOffset += 3;
}
caretOffset = CharArrayUtil.shiftBackward(chars, caretOffset - 1, " \t") + 1;
if (CharArrayUtil.regionMatches(chars, caretOffset - "{}".length(), "{}")
|| CharArrayUtil.regionMatches(chars, caretOffset - "{\n}".length(), "{\n}")) {
commit(editor);
final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(file.getProject());
final boolean old = settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE;
settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE = false;
PsiElement elt =
PsiTreeUtil.getParentOfType(file.findElementAt(caretOffset - 1), PsiCodeBlock.class);
reformat(elt);
settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE = old;
editor.getCaretModel().moveToOffset(caretOffset - 1);
}
}
protected void restoreState(@NotNull final V psiField) {
if (!ReadonlyStatusHandler.ensureDocumentWritable(
myProject, InjectedLanguageUtil.getTopLevelEditor(myEditor).getDocument())) return;
ApplicationManager.getApplication()
.runWriteAction(
() -> {
final PsiFile containingFile = psiField.getContainingFile();
final RangeMarker exprMarker = getExprMarker();
if (exprMarker != null) {
myExpr = restoreExpression(containingFile, psiField, exprMarker, myExprText);
}
if (myLocalMarker != null) {
final PsiElement refVariableElement =
containingFile.findElementAt(myLocalMarker.getStartOffset());
if (refVariableElement != null) {
final PsiElement parent = refVariableElement.getParent();
if (parent instanceof PsiNamedElement) {
((PsiNamedElement) parent).setName(myLocalName);
}
}
final V localVariable = getLocalVariable();
if (localVariable != null && localVariable.isPhysical()) {
myLocalVariable = localVariable;
final PsiElement nameIdentifier = localVariable.getNameIdentifier();
if (nameIdentifier != null) {
myLocalMarker = createMarker(nameIdentifier);
}
}
}
final List<RangeMarker> occurrenceMarkers = getOccurrenceMarkers();
for (int i = 0, occurrenceMarkersSize = occurrenceMarkers.size();
i < occurrenceMarkersSize;
i++) {
RangeMarker marker = occurrenceMarkers.get(i);
if (getExprMarker() != null
&& marker.getStartOffset() == getExprMarker().getStartOffset()
&& myExpr != null) {
myOccurrences[i] = myExpr;
continue;
}
final E psiExpression =
restoreExpression(
containingFile,
psiField,
marker,
getLocalVariable() != null ? myLocalName : myExprText);
if (psiExpression != null) {
myOccurrences[i] = psiExpression;
}
}
if (myExpr != null && myExpr.isPhysical()) {
myExprMarker = createMarker(myExpr);
}
myOccurrenceMarkers = null;
deleteTemplateField(psiField);
});
}
@Nullable
public PsiElement getSubstituted() {
if (mySubstituted != null && mySubstituted.isValid()) {
if (mySubstituted instanceof PsiNameIdentifierOwner) {
if (Comparing.strEqual(myOldName, ((PsiNameIdentifierOwner) mySubstituted).getName()))
return mySubstituted;
final RangeMarker rangeMarker =
mySubstitutedRange != null ? mySubstitutedRange : myRenameOffset;
if (rangeMarker != null)
return PsiTreeUtil.getParentOfType(
mySubstituted.getContainingFile().findElementAt(rangeMarker.getStartOffset()),
PsiNameIdentifierOwner.class);
}
return mySubstituted;
}
if (mySubstitutedRange != null) {
final PsiFile psiFile =
PsiDocumentManager.getInstance(myProject).getPsiFile(myEditor.getDocument());
if (psiFile != null) {
return PsiTreeUtil.getParentOfType(
psiFile.findElementAt(mySubstitutedRange.getStartOffset()),
PsiNameIdentifierOwner.class);
}
}
return getVariable();
}
public static TextWithImports getEditorText(final Editor editor) {
if (editor == null) {
return null;
}
final Project project = editor.getProject();
if (project == null) return null;
String defaultExpression = editor.getSelectionModel().getSelectedText();
if (defaultExpression == null) {
int offset = editor.getCaretModel().getOffset();
PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
if (psiFile != null) {
PsiElement elementAtCursor = psiFile.findElementAt(offset);
if (elementAtCursor != null) {
final EditorTextProvider textProvider =
EditorTextProvider.EP.forLanguage(elementAtCursor.getLanguage());
if (textProvider != null) {
final TextWithImports editorText = textProvider.getEditorText(elementAtCursor);
if (editorText != null) return editorText;
}
}
}
} else {
return new TextWithImportsImpl(CodeFragmentKind.EXPRESSION, defaultExpression);
}
return null;
}
public static PsiElement[] parsePattern(
Project project,
String context,
String pattern,
FileType fileType,
Language language,
String extension,
boolean physical) {
int offset = context.indexOf(PATTERN_PLACEHOLDER);
final int patternLength = pattern.length();
final String patternInContext = context.replace(PATTERN_PLACEHOLDER, pattern);
final String ext = extension != null ? extension : fileType.getDefaultExtension();
final String name = "__dummy." + ext;
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiFile file =
language == null
? factory.createFileFromText(
name, fileType, patternInContext, LocalTimeCounter.currentTime(), physical, true)
: factory.createFileFromText(name, language, patternInContext, physical, true);
if (file == null) {
return PsiElement.EMPTY_ARRAY;
}
final List<PsiElement> result = new ArrayList<PsiElement>();
PsiElement element = file.findElementAt(offset);
if (element == null) {
return PsiElement.EMPTY_ARRAY;
}
PsiElement topElement = element;
element = element.getParent();
while (element != null) {
if (element.getTextRange().getStartOffset() == offset
&& element.getTextLength() <= patternLength) {
topElement = element;
}
element = element.getParent();
}
if (topElement instanceof PsiFile) {
return topElement.getChildren();
}
final int endOffset = offset + patternLength;
result.add(topElement);
topElement = topElement.getNextSibling();
while (topElement != null && topElement.getTextRange().getEndOffset() <= endOffset) {
result.add(topElement);
topElement = topElement.getNextSibling();
}
return result.toArray(new PsiElement[result.size()]);
}
@Nullable
private static PsiClass findTargetClass(@NotNull Editor editor, @NotNull PsiFile file) {
int offset = editor.getCaretModel().getOffset();
PsiElement element = file.findElementAt(offset);
return PsiTreeUtil.getParentOfType(element, PsiClass.class, false) == null
? null
: TestIntegrationUtils.findOuterClass(element);
}
/** Decompiler aware version */
@Nullable
public static PsiElement findElementAt(@Nullable PsiFile file, int offset) {
if (file instanceof PsiCompiledFile) {
file = ((PsiCompiledFile) file).getDecompiledPsiFile();
}
if (file == null) return null;
return file.findElementAt(offset);
}
@Override
public void invoke(
@NotNull final Project project, @NotNull Editor editor, @NotNull PsiFile file) {
PsiDocumentManager.getInstance(project).commitAllDocuments();
DumbService.getInstance(project).setAlternativeResolveEnabled(true);
try {
int offset = editor.getCaretModel().getOffset();
PsiElement[] elements =
underModalProgress(
project,
"Resolving Reference...",
() -> findAllTargetElements(project, editor, offset));
FeatureUsageTracker.getInstance().triggerFeatureUsed("navigation.goto.declaration");
if (elements.length != 1) {
if (elements.length == 0
&& suggestCandidates(TargetElementUtil.findReference(editor, offset)).isEmpty()) {
PsiElement element =
findElementToShowUsagesOf(editor, editor.getCaretModel().getOffset());
if (startFindUsages(editor, element)) {
return;
}
// disable 'no declaration found' notification for keywords
final PsiElement elementAtCaret = file.findElementAt(offset);
if (elementAtCaret != null) {
final NamesValidator namesValidator =
LanguageNamesValidation.INSTANCE.forLanguage(elementAtCaret.getLanguage());
if (namesValidator != null
&& namesValidator.isKeyword(elementAtCaret.getText(), project)) {
return;
}
}
}
chooseAmbiguousTarget(editor, offset, elements, file);
return;
}
PsiElement element = elements[0];
if (element == findElementToShowUsagesOf(editor, editor.getCaretModel().getOffset())
&& startFindUsages(editor, element)) {
return;
}
PsiElement navElement = element.getNavigationElement();
navElement = TargetElementUtil.getInstance().getGotoDeclarationTarget(element, navElement);
if (navElement != null) {
gotoTargetElement(navElement, editor, file);
}
} catch (IndexNotReadyException e) {
DumbService.getInstance(project)
.showDumbModeNotification("Navigation is not available here during index update");
} finally {
DumbService.getInstance(project).setAlternativeResolveEnabled(false);
}
}
private static boolean isOnIdentifier(PsiFile file, int offset) {
final PsiElement psiElement = file.findElementAt(offset);
if (psiElement instanceof PsiIdentifier) {
if (psiElement.getParent() instanceof PsiMethod) {
return true;
}
}
return false;
}
@Nullable
private static XmlTag getEditorTag(Editor editor, PsiFile file) {
final int offset = editor.getCaretModel().getOffset();
final PsiElement psiElement = file.findElementAt(offset);
if (psiElement != null) {
return PsiTreeUtil.getParentOfType(psiElement, XmlTag.class, false);
}
return null;
}
@Nullable
private static PsiMethod getMethodImpl(final DataContext dataContext) {
final Project project = PlatformDataKeys.PROJECT.getData(dataContext);
if (project == null) return null;
PsiElement element = LangDataKeys.PSI_ELEMENT.getData(dataContext);
final PsiMethod method = PsiTreeUtil.getParentOfType(element, PsiMethod.class, false);
if (method != null) {
return method;
}
final Editor editor = PlatformDataKeys.EDITOR.getData(dataContext);
if (editor == null) {
return null;
}
final PsiFile psiFile =
PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
if (psiFile == null) {
return null;
}
PsiDocumentManager.getInstance(project).commitAllDocuments();
final int offset = editor.getCaretModel().getOffset();
if (offset < 1) {
return null;
}
element = psiFile.findElementAt(offset);
if (!(element instanceof PsiWhiteSpace)) {
return null;
}
element = psiFile.findElementAt(offset - 1);
if (!(element instanceof PsiJavaToken)
|| ((PsiJavaToken) element).getTokenType() != JavaTokenType.SEMICOLON) {
return null;
}
return PsiTreeUtil.getParentOfType(element, PsiMethod.class, false);
}
@Nullable
protected static PsiLanguageInjectionHost findInjectionHost(Editor editor, PsiFile file) {
if (editor instanceof EditorWindow) return null;
final int offset = editor.getCaretModel().getOffset();
final PsiLanguageInjectionHost host =
PsiTreeUtil.getParentOfType(
file.findElementAt(offset), PsiLanguageInjectionHost.class, false);
if (host == null) return null;
return host.isValidHost() ? host : null;
}
@Override
public void beforeCompletion(@NotNull final CompletionInitializationContext context) {
final PsiFile file = context.getFile();
if (file instanceof PsiJavaFile) {
JavaCompletionUtil.initOffsets(file, context.getOffsetMap());
autoImport(file, context.getStartOffset() - 1, context.getEditor());
if (context.getCompletionType() == CompletionType.BASIC) {
if (semicolonNeeded(context.getEditor(), file, context.getStartOffset())) {
context.setDummyIdentifier(CompletionInitializationContext.DUMMY_IDENTIFIER.trim() + ";");
return;
}
final PsiJavaCodeReferenceElement ref =
PsiTreeUtil.findElementOfClassAtOffset(
file, context.getStartOffset(), PsiJavaCodeReferenceElement.class, false);
if (ref != null && !(ref instanceof PsiReferenceExpression)) {
if (ref.getParent() instanceof PsiTypeElement) {
context.setDummyIdentifier(
CompletionInitializationContext.DUMMY_IDENTIFIER.trim() + ";");
}
if (JavaSmartCompletionContributor.AFTER_NEW.accepts(ref)) {
final PsiReferenceParameterList paramList = ref.getParameterList();
if (paramList != null && paramList.getTextLength() > 0) {
context
.getOffsetMap()
.addOffset(
ConstructorInsertHandler.PARAM_LIST_START,
paramList.getTextRange().getStartOffset());
context
.getOffsetMap()
.addOffset(
ConstructorInsertHandler.PARAM_LIST_END,
paramList.getTextRange().getEndOffset());
}
}
return;
}
final PsiElement element = file.findElementAt(context.getStartOffset());
if (psiElement().inside(PsiAnnotation.class).accepts(element)) {
return;
}
context.setDummyIdentifier(CompletionInitializationContext.DUMMY_IDENTIFIER_TRIMMED);
}
}
}
private static int findOffsetToInsertMethodTo(Editor editor, PsiFile file) {
int result = editor.getCaretModel().getOffset();
PsiClass classAtCursor =
PsiTreeUtil.getParentOfType(file.findElementAt(result), PsiClass.class, false);
while (classAtCursor != null && !(classAtCursor.getParent() instanceof PsiFile)) {
result = classAtCursor.getTextRange().getEndOffset();
classAtCursor = PsiTreeUtil.getParentOfType(classAtCursor, PsiClass.class);
}
return result;
}
@Nullable
public static TextRange getSelectedRange(Editor editor, final PsiFile psiFile) {
if (editor == null) return null;
String selectedText = editor.getSelectionModel().getSelectedText();
if (selectedText != null) {
return new TextRange(
editor.getSelectionModel().getSelectionStart(),
editor.getSelectionModel().getSelectionEnd());
}
PsiElement psiElement = psiFile.findElementAt(editor.getCaretModel().getOffset());
if (psiElement == null || psiElement instanceof PsiWhiteSpace) return null;
return psiElement.getTextRange();
}
private static PsiExpression getExpressionToSimplify(final Editor editor, final PsiFile file) {
int offset = editor.getCaretModel().getOffset();
PsiElement element = file.findElementAt(offset);
if (element == null) return null;
PsiExpression expression = PsiTreeUtil.getParentOfType(element, PsiExpression.class);
PsiElement parent = expression;
while (parent instanceof PsiExpression
&& (PsiType.BOOLEAN.equals(((PsiExpression) parent).getType())
|| parent instanceof PsiConditionalExpression)) {
expression = (PsiExpression) parent;
parent = parent.getParent();
}
return expression;
}
public PsiElement getTarget(@NotNull final DataContext dataContext) {
final Project project = CommonDataKeys.PROJECT.getData(dataContext);
if (project == null) return null;
final Editor editor = CommonDataKeys.EDITOR.getData(dataContext);
if (LOG.isDebugEnabled()) {
LOG.debug("editor " + editor);
}
if (editor != null) {
final PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
if (file == null) return null;
final PsiElement targetElement =
TargetElementUtilBase.findTargetElement(
editor,
TargetElementUtilBase.ELEMENT_NAME_ACCEPTED
| TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED
| TargetElementUtilBase.LOOKUP_ITEM_ACCEPTED);
if (LOG.isDebugEnabled()) {
LOG.debug("target element " + targetElement);
}
if (targetElement instanceof PsiClass) {
return targetElement;
}
final int offset = editor.getCaretModel().getOffset();
PsiElement element = file.findElementAt(offset);
while (element != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("context element " + element);
}
if (element instanceof PsiFile) {
if (!(element instanceof PsiClassOwner)) return null;
final PsiClass[] classes = ((PsiClassOwner) element).getClasses();
return classes.length == 1 ? classes[0] : null;
}
if (element instanceof PsiClass
&& !(element instanceof PsiAnonymousClass)
&& !(element instanceof PsiSyntheticClass)) {
return element;
}
element = element.getParent();
}
return null;
} else {
final PsiElement element = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
return element instanceof PsiClass ? (PsiClass) element : null;
}
}
private static PsiElement itIsTheClosingCurlyBraceWeAreMoving(
final PsiFile file, final Editor editor) {
LineRange range = getLineRangeFromSelection(editor);
if (range.endLine - range.startLine != 1) return null;
int offset = editor.getCaretModel().getOffset();
Document document = editor.getDocument();
int line = document.getLineNumber(offset);
int lineStartOffset = document.getLineStartOffset(line);
String lineText =
document.getText().substring(lineStartOffset, document.getLineEndOffset(line));
if (!lineText.trim().equals("}")) return null;
return file.findElementAt(lineStartOffset + lineText.indexOf('}'));
}
@Nullable
public static PsiElement[] findTargetElementsNoVS(
Project project, Editor editor, int offset, boolean lookupAccepted) {
Document document = editor.getDocument();
PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(document);
if (file == null) return null;
PsiElement elementAt =
file.findElementAt(TargetElementUtil.adjustOffset(file, document, offset));
for (GotoDeclarationHandler handler :
Extensions.getExtensions(GotoDeclarationHandler.EP_NAME)) {
try {
PsiElement[] result = handler.getGotoDeclarationTargets(elementAt, offset, editor);
if (result != null && result.length > 0) {
for (PsiElement element : result) {
if (element == null) {
LOG.error("Null target element is returned by " + handler.getClass().getName());
return null;
}
}
return result;
}
} catch (AbstractMethodError e) {
LOG.error(new ExtensionException(handler.getClass()));
}
}
int flags =
TargetElementUtil.getInstance().getAllAccepted() & ~TargetElementUtil.ELEMENT_NAME_ACCEPTED;
if (!lookupAccepted) {
flags &= ~TargetElementUtil.LOOKUP_ITEM_ACCEPTED;
}
PsiElement element = TargetElementUtil.getInstance().findTargetElement(editor, flags, offset);
if (element != null) {
return new PsiElement[] {element};
}
// if no references found in injected fragment, try outer document
if (editor instanceof EditorWindow) {
EditorWindow window = (EditorWindow) editor;
return findTargetElementsNoVS(
project,
window.getDelegate(),
window.getDocument().injectedToHost(offset),
lookupAccepted);
}
return null;
}
private static TextRange calculateLimitRange(
final PsiFile file, final Document doc, final int line) {
final int offset = doc.getLineStartOffset(line);
if (offset > 0) {
PsiMethod method =
PsiTreeUtil.getParentOfType(file.findElementAt(offset), PsiMethod.class, false);
if (method != null) {
final TextRange elemRange = method.getTextRange();
return new TextRange(
doc.getLineNumber(elemRange.getStartOffset()),
doc.getLineNumber(elemRange.getEndOffset()));
}
}
return new TextRange(0, doc.getLineCount() - 1);
}
@Nullable
private static Runnable generateAnonymousBody(final Editor editor, final PsiFile file) {
final Project project = file.getProject();
PsiDocumentManager.getInstance(project).commitAllDocuments();
int offset = editor.getCaretModel().getOffset();
PsiElement element = file.findElementAt(offset);
if (element == null) return null;
PsiElement parent = element.getParent().getParent();
if (!(parent instanceof PsiAnonymousClass)) return null;
return ConstructorInsertHandler.genAnonymousBodyFor(
(PsiAnonymousClass) parent, editor, file, project);
}
public static PsiMethod findPsiMethod(PsiFile file, int offset) {
PsiElement element = null;
while (offset >= 0) {
element = file.findElementAt(offset);
if (element != null) break;
offset--;
}
for (; element != null; element = element.getParent()) {
if (element instanceof PsiClass) return null;
if (element instanceof PsiMethod) return (PsiMethod) element;
}
return null;
}
