@NotNull
@Override
public PsiCatchSection createCatchSection(
@NotNull final PsiType exceptionType,
@NotNull final String exceptionName,
@Nullable final PsiElement context)
throws IncorrectOperationException {
if (!(exceptionType instanceof PsiClassType || exceptionType instanceof PsiDisjunctionType)) {
throw new IncorrectOperationException("Unexpected type:" + exceptionType);
}
@NonNls
final String text = "catch (" + exceptionType.getCanonicalText() + " " + exceptionName + ") {}";
final DummyHolder holder =
DummyHolderFactory.createHolder(
myManager, new JavaDummyElement(text, CATCH_SECTION, level(context)), context);
final PsiElement element =
SourceTreeToPsiMap.treeElementToPsi(holder.getTreeElement().getFirstChildNode());
if (!(element instanceof PsiCatchSection)) {
throw new IncorrectOperationException(
"Incorrect catch section '" + text + "'. Parsed element: " + element);
}
final Project project = myManager.getProject();
final JavaPsiImplementationHelper helper = JavaPsiImplementationHelper.getInstance(project);
helper.setupCatchBlock(exceptionName, exceptionType, context, (PsiCatchSection) element);
final CodeStyleManager styleManager = CodeStyleManager.getInstance(project);
final PsiCatchSection catchSection = (PsiCatchSection) styleManager.reformat(element);
GeneratedMarkerVisitor.markGenerated(catchSection);
return catchSection;
}
@NotNull
private PsiAnnotation createAnnotationFromText(@NotNull final String text)
throws IncorrectOperationException {
// synchronize during interning in charTable
synchronized (charTable) {
final DummyHolder holder =
DummyHolderFactory.createHolder(
myPsiManager,
new JavaDummyElement(text, ANNOTATION, LanguageLevel.HIGHEST),
null,
charTable);
final PsiElement element =
SourceTreeToPsiMap.treeElementToPsi(holder.getTreeElement().getFirstChildNode());
if (!(element instanceof PsiAnnotation)) {
throw new IncorrectOperationException("Incorrect annotation \"" + text + "\".");
}
return (PsiAnnotation) element;
}
}
@NotNull
public static PsiAnnotationMemberValue createMemberValueFromText(
final String text, final PsiManager manager, final ClsElementImpl parent) {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
final PsiJavaFile context =
((PsiJavaParserFacadeImpl) factory).getDummyJavaFile(); // to resolve classes from java.lang
final LanguageLevel level = PsiUtil.getLanguageLevel(parent);
final DummyHolder holder =
DummyHolderFactory.createHolder(
manager, new JavaDummyElement(text, ANNOTATION_VALUE, level), context);
final PsiElement element =
SourceTreeToPsiMap.treeElementToPsi(holder.getTreeElement().getFirstChildNode());
if (!(element instanceof PsiAnnotationMemberValue)) {
LOG.error("Could not parse initializer:'" + text + "'");
return null;
}
return getMemberValue(element, parent);
}
@NotNull
@Override
public PsiElement createDummyHolder(
@NotNull final String text,
@NotNull final IElementType type,
@Nullable final PsiElement context) {
final DummyHolder result = DummyHolderFactory.createHolder(myManager, context);
final FileElement holder = result.getTreeElement();
final Language language = type.getLanguage();
final ParserDefinition parserDefinition =
LanguageParserDefinitions.INSTANCE.forLanguage(language);
assert parserDefinition != null : "No parser definition for language " + language;
final Project project = myManager.getProject();
final Lexer lexer = parserDefinition.createLexer(project);
final PsiBuilder builder =
PsiBuilderFactory.getInstance().createBuilder(project, holder, lexer, language, text);
final ASTNode node = parserDefinition.createParser(project).parse(type, builder);
holder.rawAddChildren((TreeElement) node);
final PsiElement psi = node.getPsi();
assert psi != null : text;
return psi;
}
public ASTNode encodeXmlTextContents(String displayText, PsiElement text) {
final PsiFile containingFile = text.getContainingFile();
CharTable charTable = SharedImplUtil.findCharTableByTree(text.getNode());
final FileElement dummyParent =
DummyHolderFactory.createHolder(text.getManager(), null, charTable).getTreeElement();
final XmlTag rootTag =
((XmlFile)
PsiFileFactory.getInstance(containingFile.getProject())
.createFileFromText("a.xml", "<a>" + displayText + "</a>"))
.getRootTag();
assert rootTag != null;
final XmlTagChild[] tagChildren = rootTag.getValue().getChildren();
final XmlTagChild child = tagChildren.length > 0 ? tagChildren[0] : null;
LOG.assertTrue(child != null, "Child is null for tag: " + rootTag.getText());
final TreeElement element = (TreeElement) child.getNode();
((TreeElement) tagChildren[tagChildren.length - 1].getNode().getTreeNext()).rawRemoveUpToLast();
dummyParent.rawAddChildren(element);
TreeUtil.clearCaches(dummyParent);
return element.getFirstChildNode();
}
/**
* This method searches ast node that could be reparsed incrementally and returns pair of target
* reparseable node and new replacement node. Returns null if there is no any chance to make
* incremental parsing.
*/
@Nullable
public Couple<ASTNode> findReparseableRoots(
@NotNull PsiFileImpl file,
@NotNull TextRange changedPsiRange,
@NotNull CharSequence newFileText) {
Project project = file.getProject();
final FileElement fileElement = file.getTreeElement();
final CharTable charTable = fileElement.getCharTable();
int lengthShift = newFileText.length() - fileElement.getTextLength();
if (fileElement.getElementType() instanceof ITemplateDataElementType || isTooDeep(file)) {
// unable to perform incremental reparse for template data in JSP, or in exceptionally deep
// trees
return null;
}
final ASTNode leafAtStart =
fileElement.findLeafElementAt(Math.max(0, changedPsiRange.getStartOffset() - 1));
final ASTNode leafAtEnd =
fileElement.findLeafElementAt(
Math.min(changedPsiRange.getEndOffset(), fileElement.getTextLength() - 1));
ASTNode node =
leafAtStart != null && leafAtEnd != null
? TreeUtil.findCommonParent(leafAtStart, leafAtEnd)
: fileElement;
Language baseLanguage = file.getViewProvider().getBaseLanguage();
while (node != null && !(node instanceof FileElement)) {
IElementType elementType = node.getElementType();
if (elementType instanceof IReparseableElementType) {
final TextRange textRange = node.getTextRange();
final IReparseableElementType reparseable = (IReparseableElementType) elementType;
if (baseLanguage.isKindOf(reparseable.getLanguage())
&& textRange.getLength() + lengthShift > 0) {
final int start = textRange.getStartOffset();
final int end = start + textRange.getLength() + lengthShift;
if (end > newFileText.length()) {
reportInconsistentLength(file, newFileText, node, start, end);
break;
}
CharSequence newTextStr = newFileText.subSequence(start, end);
if (reparseable.isParsable(node.getTreeParent(), newTextStr, baseLanguage, project)) {
ASTNode chameleon = reparseable.createNode(newTextStr);
if (chameleon != null) {
DummyHolder holder =
DummyHolderFactory.createHolder(
file.getManager(), null, node.getPsi(), charTable);
holder.getTreeElement().rawAddChildren((TreeElement) chameleon);
if (holder.getTextLength() != newTextStr.length()) {
String details =
ApplicationManager.getApplication().isInternal()
? "text=" + newTextStr + "; treeText=" + holder.getText() + ";"
: "";
LOG.error("Inconsistent reparse: " + details + " type=" + elementType);
}
return Couple.of(node, chameleon);
}
}
}
}
node = node.getTreeParent();
}
return null;
}
