下面列出了怎么用com.intellij.psi.impl.source.tree.TreeElement的API类实例代码及写法,或者点击链接到github查看源代码。
protected void parseMapConfigElement(TreeElement mapConfigElement) {
if (null == mapConfigElement) {
return;
}
if (mapConfigElement.getElementType() == JSElementTypes.PROPERTY) {
String module = getJSPropertyName(mapConfigElement);
TreeElement mapAliasesObject = (TreeElement) mapConfigElement
.findChildByType(JSElementTypes.OBJECT_LITERAL_EXPRESSION);
if (null != mapAliasesObject) {
RequireMapModule requireMapModule = new RequireMapModule();
requireMapModule.module = module;
TreeElement mapAliasProperty = (TreeElement) mapAliasesObject.findChildByType(JSElementTypes.PROPERTY);
parseMapAliasProperty(requireMapModule, mapAliasProperty);
requireMap.addModule(requireMapModule);
}
}
parseMapConfigElement(mapConfigElement.getTreeNext());
}
protected void parseMapAliasProperty(RequireMapModule requireMapModule, TreeElement mapAliasProperty) {
if (null == mapAliasProperty) {
return;
}
if (mapAliasProperty.getElementType() == JSElementTypes.PROPERTY) {
RequirePathAlias alias = new RequirePathAlias();
alias.alias = getJSPropertyName(mapAliasProperty);
alias.path = getJSPropertyLiteralValue(mapAliasProperty);
if (null != alias.alias && alias.path != null) {
requireMapModule.addAlias(alias);
} else {
LOG.debug("Error parse require js path", alias);
}
}
parseMapAliasProperty(requireMapModule, mapAliasProperty.getTreeNext());
}
private void parsePackage(TreeElement node) {
if (null == node) {
return;
}
if (node.getElementType() == JSElementTypes.OBJECT_LITERAL_EXPRESSION
|| node.getElementType() == JSElementTypes.LITERAL_EXPRESSION
) {
// TODO: Not adding not resolve package
Package p = new Package();
packageConfig.packages.add(p);
if (node.getElementType() == JSElementTypes.OBJECT_LITERAL_EXPRESSION) {
TreeElement prop = (TreeElement) node.findChildByType(JSElementTypes.PROPERTY);
parsePackageObject(prop, p);
} else {
p.name = dequote(node.getText());
}
normalizeParsedPackage(p);
validatePackage(p);
}
TreeElement next = node.getTreeNext();
parsePackage(next);
}
protected void parseRequireJsPaths(TreeElement node) {
if (null == node) {
return ;
}
if (node.getElementType() == JSElementTypes.PROPERTY) {
RequirePathAlias pathAlias = new RequirePathAlias();
pathAlias.alias = getJSPropertyName(node);
pathAlias.path = getJSPropertyLiteralValue(node);
requirePaths.addPath(pathAlias);
}
TreeElement next = node.getTreeNext();
if (null != next) {
parseRequireJsPaths(next);
}
}
private static TreeElement findNextLeafElementAt(ASTNode scopeNode, TreeElement last, int offset) {
int offsetR = offset;
if (last != null) {
offsetR -= last.getStartOffset() - scopeNode.getStartOffset() + last.getTextLength();
while (offsetR >= 0) {
TreeElement next = last.getTreeNext();
if (next == null) {
last = last.getTreeParent();
continue;
}
int length = next.getTextLength();
offsetR -= length;
last = next;
}
scopeNode = last;
offsetR += scopeNode.getTextLength();
}
return (LeafElement)scopeNode.findLeafElementAt(offsetR);
}
static boolean processElementsAtOffsets(@Nonnull PsiElement scope,
@Nonnull StringSearcher searcher,
boolean processInjectedPsi,
@Nonnull ProgressIndicator progress,
int[] offsetsInScope,
@Nonnull TextOccurenceProcessor processor) {
if (offsetsInScope.length == 0) return true;
Project project = scope.getProject();
TreeElement lastElement = null;
for (int offset : offsetsInScope) {
progress.checkCanceled();
lastElement = processTreeUp(project, processor, scope, searcher, offset, processInjectedPsi, progress, lastElement);
if (lastElement == null) return false;
}
return true;
}
@Nullable
private static PsiFile getContainingFileByTree(@Nonnull final PsiElement changeScope) {
// there could be pseudo physical trees (JSPX/JSP/etc.) which must not translate
// any changes to document and not to fire any PSI events
final PsiFile psiFile;
final ASTNode node = changeScope.getNode();
if (node == null) {
psiFile = changeScope.getContainingFile();
}
else {
final FileElement fileElement = TreeUtil.getFileElement((TreeElement)node);
// assert fileElement != null : "Can't find file element for node: " + node;
// Hack. the containing tree can be invalidated if updating supplementary trees like HTML in JSP.
if (fileElement == null) return null;
psiFile = (PsiFile)fileElement.getPsi();
}
return psiFile.getNode() != null ? psiFile : null;
}
public DummyHolder(@Nonnull PsiManager manager, @Nullable TreeElement contentElement, @Nullable PsiElement context, @Nullable CharTable table, @Nullable Boolean validity, Language language) {
super(TokenType.DUMMY_HOLDER, TokenType.DUMMY_HOLDER, new DummyHolderViewProvider(manager));
myLanguage = language;
((DummyHolderViewProvider)getViewProvider()).setDummyHolder(this);
myContext = context;
myTable = table != null ? table : IdentityCharTable.INSTANCE;
if (contentElement instanceof FileElement) {
((FileElement)contentElement).setPsi(this);
((FileElement)contentElement).setCharTable(myTable);
setTreeElementPointer((FileElement)contentElement);
}
else if (contentElement != null) {
getTreeElement().rawAddChildren(contentElement);
clearCaches();
}
myExplicitlyValid = validity;
}
private static void markToReformatBeforeOrInsertWhitespace(final ASTNode left, @Nonnull final ASTNode right) {
final Language leftLang = left != null ? PsiUtilCore.getNotAnyLanguage(left) : null;
final Language rightLang = PsiUtilCore.getNotAnyLanguage(right);
ASTNode generatedWhitespace = null;
if (leftLang != null && leftLang.isKindOf(rightLang)) {
generatedWhitespace = LanguageTokenSeparatorGenerators.INSTANCE.forLanguage(leftLang).generateWhitespaceBetweenTokens(left, right);
}
else if (rightLang.isKindOf(leftLang)) {
generatedWhitespace = LanguageTokenSeparatorGenerators.INSTANCE.forLanguage(rightLang).generateWhitespaceBetweenTokens(left, right);
}
if (generatedWhitespace != null) {
final TreeUtil.CommonParentState parentState = new TreeUtil.CommonParentState();
TreeUtil.prevLeaf((TreeElement)right, parentState);
parentState.nextLeafBranchStart.getTreeParent().addChild(generatedWhitespace, parentState.nextLeafBranchStart);
}
else {
markToReformatBefore(right, true);
}
}
@Nullable
public PsiElement createElementFromText(@Nullable final String text,
@Nonnull final Language language,
@Nonnull final LanguageVersion languageVersion,
@Nonnull final IElementType type,
@Nullable final PsiElement context) {
if (text == null) return null;
final DummyHolder result = DummyHolderFactory.createHolder(myManager, language, context);
final FileElement holder = result.getTreeElement();
final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
if (parserDefinition == null) {
throw new AssertionError("No parser definition for " + language);
}
final Project project = myManager.getProject();
final Lexer lexer = parserDefinition.createLexer(languageVersion);
final PsiBuilder builder = PsiBuilderFactory.getInstance().createBuilder(project, holder, lexer, language, languageVersion, text);
final ASTNode node = parserDefinition.createParser(languageVersion).parse(type, builder, languageVersion);
holder.rawAddChildren((TreeElement)node);
markGenerated(result);
return node.getPsi();
}
private void restoreCaretPosition(final PsiFile file) {
((TreeElement)file.getNode()).acceptTree(new RecursiveTreeElementWalkingVisitor() {
@Override
protected void visitNode(TreeElement element) {
PsiElement el = element.getPsi();
Integer offset = el.getCopyableUserData(CARET_POS_KEY);
// continue;
if (offset != null) {
myEditor.getCaretModel().moveToOffset(el.getTextOffset() + offset);
el.putCopyableUserData(CARET_POS_KEY, null);
return;
}
super.visitNode(element);
}
});
}
/**
* This method is used in order to add elements to the back of a map,
* it is derived from {@link ASTDelegatePsiElement#addInternal(ASTNode, ASTNode, ASTNode, Boolean)}.
*/
private static PsiElement realAddBefore(@NotNull GrListOrMap element, @NotNull PsiElement newElement, @NotNull PsiElement anchor) {
CheckUtil.checkWritable(element);
TreeElement elementCopy = ChangeUtil.copyToElement(newElement);
ASTNode anchorNode = getAnchorNode(element, anchor.getNode(), true);
ASTNode newNode = CodeEditUtil.addChildren(element.getNode(), elementCopy, elementCopy, anchorNode);
if (newNode == null) {
throw new IncorrectOperationException("Element cannot be added");
}
if (newNode instanceof TreeElement) {
return ChangeUtil.decodeInformation((TreeElement)newNode).getPsi();
}
return newNode.getPsi();
}
@Nullable
@Override
public TreeElement generateTreeFor(PsiElement original, CharTable table, PsiManager manager) {
TreeElement result = null;
if (original instanceof SqliteMagicLightMethodBuilder) {
result = ChangeUtil.copyElement((TreeElement) SourceTreeToPsiMap.psiElementToTree(original), table);
}
return result;
}
@RequiredReadAction
@Override
public void beforeMove(@Nonnull final Editor editor, @Nonnull final MoveInfo info, final boolean down)
{
super.beforeMove(editor, info, down);
if(myEnumToInsertSemicolonAfter != null)
{
TreeElement semicolon = Factory.createSingleLeafElement(CSharpTokens.SEMICOLON, ";", 0, 1, null, myEnumToInsertSemicolonAfter.getManager());
try
{
PsiElement inserted = myEnumToInsertSemicolonAfter.getParent().addAfter(semicolon.getPsi(), myEnumToInsertSemicolonAfter);
inserted = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(inserted);
final LogicalPosition position = editor.offsetToLogicalPosition(inserted.getTextRange().getEndOffset());
info.toMove2 = new LineRange(position.line + 1, position.line + 1);
}
catch(IncorrectOperationException e)
{
LOG.error(e);
}
finally
{
myEnumToInsertSemicolonAfter = null;
}
}
}
@Override
@RequiredUIAccess
public void invoke(@Nonnull Project project, Editor editor, PsiFile file) throws IncorrectOperationException
{
DotNetVariable element = myVariablePointer.getElement();
if(element == null)
{
return;
}
PsiDocumentManager.getInstance(project).commitAllDocuments();
String defaultValueForType = MethodGenerateUtil.getDefaultValueForType(element.toTypeRef(false), element);
if(defaultValueForType == null)
{
return;
}
DotNetExpression expression = CSharpFileFactory.createExpression(project, defaultValueForType);
PsiElement nameIdentifier = element.getNameIdentifier();
if(nameIdentifier == null)
{
return;
}
ASTNode variableNode = element.getNode();
ASTNode semicolon = variableNode.findChildByType(CSharpTokens.SEMICOLON);
variableNode.addLeaf(CSharpTokens.WHITE_SPACE, " ", semicolon);
variableNode.addLeaf(CSharpTokens.EQ, "=", semicolon);
variableNode.addLeaf(CSharpTokens.WHITE_SPACE, " ", semicolon);
ASTNode node = expression.getNode();
CodeEditUtil.setOldIndentation((TreeElement) node, 0);
variableNode.addChild(node, semicolon);
editor.getCaretModel().moveToOffset(element.getTextRange().getEndOffset());
}
@Nullable
public TreeElement generateTreeFor(PsiElement original, CharTable table, PsiManager manager) {
TreeElement result = null;
if (original instanceof LombokLightMethodBuilder) {
result = ChangeUtil.copyElement((TreeElement) SourceTreeToPsiMap.psiElementToTree(original), table);
}
return result;
}
public void parseMainJsFile(TreeElement node) {
TreeElement firstChild = node.getFirstChildNode();
if (firstChild != null) {
parseMainJsFile(firstChild);
}
TreeElement nextNode = node.getTreeNext();
if (nextNode != null) {
parseMainJsFile(nextNode);
}
if (node.getElementType() == JSTokenTypes.IDENTIFIER) {
if (node.getText().equals("requirejs") || node.getText().equals("require")) {
TreeElement treeParent = node.getTreeParent();
if (null != treeParent) {
ASTNode firstTreeChild = treeParent.findChildByType(JSElementTypes.OBJECT_LITERAL_EXPRESSION);
TreeElement nextTreeElement = treeParent.getTreeNext();
if (null != firstTreeChild) {
parseRequirejsConfig((TreeElement) firstTreeChild
.getFirstChildNode()
);
} else if (null != nextTreeElement && nextTreeElement.getElementType() == JSTokenTypes.DOT) {
nextTreeElement = nextTreeElement.getTreeNext();
if (null != nextTreeElement && nextTreeElement.getText().equals("config")) {
treeParent = nextTreeElement.getTreeParent();
findAndParseConfig(treeParent);
}
} else {
findAndParseConfig(treeParent);
}
}
}
}
}
protected void findAndParseConfig(TreeElement treeParent) {
TreeElement nextTreeElement;
if (null != treeParent) {
nextTreeElement = treeParent.getTreeNext();
if (null != nextTreeElement) {
ASTNode nextChild = nextTreeElement.findChildByType(JSElementTypes.OBJECT_LITERAL_EXPRESSION);
if (null != nextChild) {
parseRequirejsConfig(
(TreeElement) nextChild.getFirstChildNode()
);
}
}
}
}
protected String getJSPropertyName(TreeElement jsProperty) {
TreeElement identifier = (TreeElement) jsProperty.findChildByType(
TokenSet.create(JSTokenTypes.IDENTIFIER, JSTokenTypes.STRING_LITERAL, JSTokenTypes.PUBLIC_KEYWORD)
);
String identifierName = null;
if (null != identifier) {
identifierName = dequote(identifier.getText());
}
return identifierName;
}
private void parsePackages(TreeElement node) {
TokenSet tokenSet = TokenSet.create(
JSElementTypes.OBJECT_LITERAL_EXPRESSION,
JSElementTypes.LITERAL_EXPRESSION);
TreeElement packageNode = (TreeElement) node.findChildByType(tokenSet);
parsePackage(packageNode);
}
private static void parsePackageObject(TreeElement node, Package p) {
if (null == node) {
return;
}
if (node.getElementType() == JSElementTypes.PROPERTY) {
TreeElement identifier = (TreeElement) node.findChildByType(JSTokenTypes.IDENTIFIER);
String identifierName = null;
if (null != identifier) {
identifierName = identifier.getText();
} else {
TreeElement identifierString = (TreeElement) node.findChildByType(JSTokenTypes.STRING_LITERAL);
if (null != identifierString) {
identifierName = dequote(identifierString.getText());
}
}
if (null != identifierName) {
if (identifierName.equals("name")) {
p.name = getJSPropertyLiteralValue(node);
} else if (identifierName.equals("location")) {
p.location = getJSPropertyLiteralValue(node);
} else if (identifierName.equals("main")) {
p.main = getJSPropertyLiteralValue(node);
}
}
}
TreeElement next = node.getTreeNext();
parsePackageObject(next, p);
}
private Map<TreeElement, ChangeInfoImpl> getAllChanges() {
Map<TreeElement, ChangeInfoImpl> changes = myChanges;
if (changes == null) {
myChanges = changes = new ChildrenDiff().calcChanges();
}
return changes;
}
Map<TreeElement, ChangeInfoImpl> calcChanges() {
advanceOld();
advanceNew();
while (oldChild != null || newChild != null) {
if (oldChild == newChild) {
if (myContentChangeChildren.contains(oldChild)) {
addChange(new ChangeInfoImpl(oldChild, oldChild, oldOffset, myInitialLengths.get(oldChild)));
}
advanceOld();
advanceNew();
}
else {
boolean oldDisappeared = oldChild != null && !currentChildren.contains(oldChild);
boolean newAppeared = newChild != null && !myInitialLengths.containsKey(newChild);
addChange(new ChangeInfoImpl(oldDisappeared ? oldChild : null, newAppeared ? newChild : null, oldOffset, oldDisappeared ? myInitialLengths.get(oldChild) : 0));
if (oldDisappeared) {
advanceOld();
}
if (newAppeared) {
advanceNew();
}
}
}
return result;
}
public void markChildChanged(@Nonnull TreeElement child, int lengthDelta) {
myContentChangeChildren.add(child);
if (lengthDelta != 0) {
myInitialLengths.computeIfPresent(child, (c, oldLength) -> oldLength - lengthDelta);
}
clearCache();
}
private boolean integrateIntoExistingChanges(CompositeElement nextParent) {
for (CompositeElement eachParent : JBIterable.generate(nextParent, TreeElement::getTreeParent)) {
CompositeElement superParent = eachParent.getTreeParent();
TreeChangeImpl superChange = myChangedElements.get(superParent);
if (superChange != null) {
superChange.markChildChanged(eachParent, 0);
return true;
}
}
return false;
}
private void mergeChange(TreeChangeImpl nextChange) {
CompositeElement newParent = nextChange.getChangedParent();
for (TreeChangeImpl descendant : new ArrayList<>(myChangesByAllParents.get(newParent))) {
TreeElement ancestorChild = findAncestorChild(newParent, descendant);
if (ancestorChild != null) {
nextChange.markChildChanged(ancestorChild, descendant.getLengthDelta());
}
unregisterChange(descendant);
}
registerChange(nextChange);
}
/**
* @return a direct child of {@code ancestor} which contains {@code change}
*/
@Nullable
private static TreeElement findAncestorChild(@Nonnull CompositeElement ancestor, @Nonnull TreeChangeImpl change) {
List<CompositeElement> superParents = change.getSuperParents();
int index = superParents.indexOf(ancestor);
return index < 0 ? null : index == 0 ? change.getChangedParent() : superParents.get(index - 1);
}
ChangeInfoImpl(@Nullable TreeElement oldChild, @Nullable TreeElement newChild, int offset, int oldLength) {
myOldChild = oldChild;
myNewChild = newChild;
myOffset = offset;
myOldLength = oldLength;
myNewLength = newChild != null ? newChild.getTextLength() : 0;
}
private void childReplaced(PsiTreeChangeEventImpl e, TreeElement oldChild, TreeElement newChild, CompositeElement parent) {
e.setParent(parent.getPsi());
e.setOldChild(oldChild.getPsi());
e.setChild(newChild.getPsi());
e.setNewChild(newChild.getPsi());
e.setOldLength(myOldLength);
getPsiManagerImpl(e).childReplaced(e);
}
@Override
void doActualPsiChange(@Nonnull PsiFile file, @Nonnull TreeChangeEventImpl changeEvent) {
TreeElement anchor = null;
TreeElement firstChildNode = myOldParent.getFirstChildNode();
for (int i = 0; i < myPos; i++) {
anchor = anchor == null ? firstChildNode : anchor.getTreeNext();
}
PsiElement psiParent = myOldParent.getPsi();
PsiElement psiChild = getPsi(myNewNode, file);
if (psiParent != null && psiChild != null) {
PsiTreeChangeEventImpl event = new PsiTreeChangeEventImpl(file.getManager());
event.setParent(psiParent);
event.setChild(psiChild);
event.setFile(file);
((PsiManagerEx)file.getManager()).beforeChildAddition(event);
}
changeEvent.addElementaryChange(myOldParent);
myNewNode.rawRemove();
if (anchor != null) {
anchor.rawInsertAfterMe(myNewNode);
}
else {
if (firstChildNode != null) {
firstChildNode.rawInsertBeforeMe(myNewNode);
}
else {
myOldParent.rawAddChildren(myNewNode);
}
}
myNewNode.clearCaches();
myOldParent.subtreeChanged();
DebugUtil.checkTreeStructure(myOldParent);
}