mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
New chameleons and fix for problem with changed elements ordering in tree events
This commit is contained in:
@@ -28,6 +28,51 @@ public abstract class Language {
|
||||
|
||||
private static Map<String, Language> ourRegisteredLanguages = new HashMap<String, Language>();
|
||||
private String myID;
|
||||
public static final Language ANY = new Language("") {
|
||||
public SyntaxHighlighter getSyntaxHighlighter(Project project) {
|
||||
return super.getSyntaxHighlighter(project); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public PseudoTextBuilder getFormatter() {
|
||||
return super.getFormatter(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public ParserDefinition getParserDefinition() {
|
||||
return super.getParserDefinition(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public WordsScanner getWordsScanner() {
|
||||
return super.getWordsScanner(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public boolean mayHaveReferences(IElementType token) {
|
||||
return super.mayHaveReferences(token); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public FoldingBuilder getFoldingBuilder() {
|
||||
return super.getFoldingBuilder(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public PairedBraceMatcher getPairedBraceMatcher() {
|
||||
return super.getPairedBraceMatcher(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public Annotator getAnnotator() {
|
||||
return super.getAnnotator(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public FindUsagesProvider getFindUsagesProvider() {
|
||||
return super.getFindUsagesProvider(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public StructureViewBuilder getStructureViewBuilder(PsiElement psiElement) {
|
||||
return super.getStructureViewBuilder(psiElement); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return super.toString(); //To change body of overridden methods use File | Settings | File Templates.
|
||||
}
|
||||
};
|
||||
|
||||
protected Language(final String ID) {
|
||||
myID = ID;
|
||||
|
||||
@@ -16,6 +16,9 @@ import com.intellij.ui.UIHelper;
|
||||
import com.intellij.ui.content.ContentFactory;
|
||||
import com.intellij.ui.errorView.ErrorViewFactory;
|
||||
import com.intellij.ide.structureView.StructureViewFactory;
|
||||
import com.intellij.lang.PsiBuilder;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.Language;
|
||||
|
||||
public abstract class PeerFactory {
|
||||
public static PeerFactory getInstance() {
|
||||
@@ -42,4 +45,6 @@ public abstract class PeerFactory {
|
||||
public abstract VcsContextFactory getVcsContextFactory();
|
||||
|
||||
public abstract StructureViewFactory getStructureViewFactory();
|
||||
|
||||
public abstract PsiBuilder createBuilder(ASTNode tree, Language lang, CharSequence seq);
|
||||
}
|
||||
@@ -26,6 +26,4 @@ public interface JavaDocTokenType {
|
||||
IElementType DOC_TAG_VALUE_SHARP_TOKEN = new IJavaDocElementType("DOC_TAG_VALUE_SHARP_TOKEN");
|
||||
|
||||
IElementType DOC_COMMENT_BAD_CHARACTER = new IJavaDocElementType("DOC_COMMENT_BAD_CHARACTER");
|
||||
IElementType DOC_REFERENCE_TEXT = new IJavaDocElementType("DOC_REFERENCE_TEXT");
|
||||
IElementType DOC_TYPE_TEXT = new IJavaDocElementType("DOC_TYPE_TEXT");
|
||||
}
|
||||
@@ -10,8 +10,8 @@ import com.intellij.psi.tree.java.IJavaElementType;
|
||||
import com.intellij.psi.tree.java.IKeywordElementType;
|
||||
|
||||
|
||||
public interface JavaTokenType {
|
||||
IElementType WHITE_SPACE = new IJavaElementType("WHITE_SPACE");
|
||||
public interface JavaTokenType extends TokenType{
|
||||
//IElementType WHITE_SPACE = new IJavaElementType("WHITE_SPACE");
|
||||
IElementType IDENTIFIER = new IJavaElementType("IDENTIFIER");
|
||||
IElementType C_STYLE_COMMENT = new IJavaElementType("C_STYLE_COMMENT");
|
||||
IElementType END_OF_LINE_COMMENT = new IJavaElementType("END_OF_LINE_COMMENT");
|
||||
@@ -134,8 +134,6 @@ public interface JavaTokenType {
|
||||
|
||||
IElementType FALSE_KEYWORD = new IKeywordElementType("FALSE_KEYWORD");
|
||||
|
||||
IElementType BAD_CHARACTER = new IJavaElementType("BAD_CHARACTER");
|
||||
|
||||
TokenSet OPERATION_BIT_SET = TokenSet.create(new IElementType[]{
|
||||
EQ, GT, LT, EXCL, TILDE, QUEST, COLON, PLUS, MINUS, ASTERISK, DIV, AND, OR, XOR,
|
||||
PERC, EQEQ, LE, GE, NE, ANDAND, OROR, PLUSPLUS, MINUSMINUS, LTLT, GTGT, GTGTGT,
|
||||
|
||||
@@ -1,20 +1,11 @@
|
||||
/*
|
||||
* Copyright (c) 2000-2004 by JetBrains s.r.o. All Rights Reserved.
|
||||
* Use is subject to license terms.
|
||||
*/
|
||||
package com.intellij.psi;
|
||||
|
||||
import com.intellij.psi.jsp.JspTokenType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.xml.DTDTokenType;
|
||||
import com.intellij.psi.xml.XmlTokenType;
|
||||
import com.intellij.lang.Language;
|
||||
|
||||
public interface TokenType extends
|
||||
JavaTokenType,
|
||||
JavaDocTokenType,
|
||||
JspTokenType,
|
||||
XmlTokenType,
|
||||
DTDTokenType,
|
||||
com.intellij.aspects.psi.gen.TokenType {
|
||||
IElementType NEW_LINE_INDENT = new IElementType("NEW_LINE_INDENT", null);
|
||||
public interface TokenType {
|
||||
IElementType WHITE_SPACE = new IElementType("WHITE_SPACE", Language.ANY);
|
||||
IElementType BAD_CHARACTER = new IElementType("BAD_CHARACTER", Language.ANY);
|
||||
|
||||
IElementType NEW_LINE_INDENT = new IElementType("NEW_LINE_INDENT", Language.ANY);
|
||||
}
|
||||
|
||||
@@ -10,6 +10,6 @@ import com.intellij.psi.tree.IElementType;
|
||||
/**
|
||||
* @author Mike
|
||||
*/
|
||||
public interface XmlToken extends XmlElement, XmlTokenType, DTDTokenType{
|
||||
public interface XmlToken extends XmlElement{
|
||||
IElementType getTokenType();
|
||||
}
|
||||
|
||||
@@ -280,7 +280,7 @@ public class XmlCompletionData extends CompletionData {
|
||||
}
|
||||
|
||||
private PsiElement getEndTagStart(PsiElement tag) {
|
||||
return XmlUtil.getTokenOfType(tag, XmlToken.XML_END_TAG_START);
|
||||
return XmlUtil.getTokenOfType(tag, XmlTokenType.XML_END_TAG_START);
|
||||
}
|
||||
|
||||
private String getTagText(PsiElement tag) {
|
||||
|
||||
@@ -20,6 +20,7 @@ import com.intellij.openapi.fileTypes.FileType;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.openapi.util.TextRange;
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.impl.source.tree.JavaDocElementType;
|
||||
import com.intellij.psi.codeStyle.CodeStyleManager;
|
||||
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
|
||||
import com.intellij.psi.javadoc.PsiDocComment;
|
||||
@@ -272,7 +273,7 @@ public class EnterHandler extends EditorWriteActionHandler {
|
||||
if (lexer.getTokenEnd() == commentText.length()) {
|
||||
return (lexer.getTokenEnd() - lexer.getTokenStart() == 1);
|
||||
}
|
||||
if (tokenType == JavaTokenType.DOC_COMMENT || tokenType == JavaTokenType.C_STYLE_COMMENT) {
|
||||
if (tokenType == JavaDocElementType.DOC_COMMENT || tokenType == JavaTokenType.C_STYLE_COMMENT) {
|
||||
return false;
|
||||
}
|
||||
lexer.advance();
|
||||
|
||||
@@ -783,7 +783,7 @@ public class TypedHandler implements TypedActionHandler {
|
||||
|
||||
IElementType tokenType = !iterator.atEnd() ? iterator.getTokenType() : null;
|
||||
if (tokenType instanceof IJavaElementType) {
|
||||
if (!TokenType.WHITE_SPACE_OR_COMMENT_BIT_SET.isInSet(tokenType)
|
||||
if (!TokenTypeEx.WHITE_SPACE_OR_COMMENT_BIT_SET.isInSet(tokenType)
|
||||
&& tokenType != JavaTokenType.SEMICOLON
|
||||
&& tokenType != JavaTokenType.COMMA
|
||||
&& tokenType != JavaTokenType.RPARENTH
|
||||
@@ -873,7 +873,7 @@ public class TypedHandler implements TypedActionHandler {
|
||||
IElementType tokenType = iterator.getTokenType();
|
||||
if (fileType == StdFileTypes.JAVA || fileType == StdFileTypes.JSP){
|
||||
if (tokenType instanceof IJavaElementType){
|
||||
if (!TokenType.WHITE_SPACE_OR_COMMENT_BIT_SET.isInSet(tokenType)
|
||||
if (!TokenTypeEx.WHITE_SPACE_OR_COMMENT_BIT_SET.isInSet(tokenType)
|
||||
&& tokenType != JavaTokenType.SEMICOLON
|
||||
&& tokenType != JavaTokenType.COMMA
|
||||
&& tokenType != JavaTokenType.RPARENTH
|
||||
|
||||
+2
-2
@@ -2,7 +2,7 @@ package com.intellij.debugger.engine.evaluation.expression;
|
||||
|
||||
import com.intellij.debugger.engine.evaluation.EvaluationContextImpl;
|
||||
import com.intellij.debugger.engine.evaluation.EvaluateException;
|
||||
import com.intellij.psi.TokenType;
|
||||
import com.intellij.psi.TokenTypeEx;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.sun.jdi.Value;
|
||||
|
||||
@@ -33,7 +33,7 @@ public class PostfixOperationEvaluator implements Evaluator{
|
||||
myValue = (Value)myOperandEvaluator.evaluate(context);
|
||||
myModifier = myOperandEvaluator.getModifier();
|
||||
|
||||
IElementType opType = myOpType == TokenType.PLUSPLUS ? TokenType.PLUS : TokenType.MINUS;
|
||||
IElementType opType = myOpType == TokenTypeEx.PLUSPLUS ? TokenTypeEx.PLUS : TokenTypeEx.MINUS;
|
||||
Object operationResult = BinaryExpressionEvaluator.evaluateOperation((Value)myValue, opType, myRightEvaluator, myExpectedType, context);
|
||||
AssignmentEvaluator.assign(myModifier, operationResult, context);
|
||||
return myValue;
|
||||
|
||||
@@ -40,6 +40,7 @@ import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.psi.JavaDocTokenType;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.StringEscapesTokenTypes;
|
||||
import com.intellij.psi.impl.source.tree.JavaDocElementType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.java.IJavaElementType;
|
||||
import com.intellij.psi.xml.XmlTokenType;
|
||||
@@ -101,7 +102,7 @@ public class JavaFileHighlighter extends SyntaxHighlighterBase {
|
||||
//ourMap1[JavaTokenType.BOOLEAN_LITERAL] = HighlighterColors.JAVA_KEYWORD;
|
||||
//ourMap1[JavaTokenType.NULL_LITERAL] = HighlighterColors.JAVA_KEYWORD;
|
||||
ourMap1.put(JavaTokenType.C_STYLE_COMMENT, HighlighterColors.JAVA_BLOCK_COMMENT);
|
||||
ourMap1.put(JavaTokenType.DOC_COMMENT, HighlighterColors.JAVA_DOC_COMMENT);
|
||||
ourMap1.put(JavaDocElementType.DOC_COMMENT, HighlighterColors.JAVA_DOC_COMMENT);
|
||||
ourMap1.put(JavaTokenType.END_OF_LINE_COMMENT, HighlighterColors.JAVA_LINE_COMMENT);
|
||||
ourMap1.put(JavaTokenType.BAD_CHARACTER, HighlighterColors.BAD_CHARACTER);
|
||||
|
||||
|
||||
@@ -3,11 +3,13 @@ package com.intellij.lang.java;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.ParserDefinition;
|
||||
import com.intellij.lang.PsiParser;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.openapi.roots.ProjectFileIndex;
|
||||
import com.intellij.openapi.roots.ProjectRootManager;
|
||||
import com.intellij.openapi.vfs.VirtualFile;
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiFile;
|
||||
import com.intellij.psi.impl.source.PsiJavaFileImpl;
|
||||
@@ -24,7 +26,7 @@ import com.intellij.psi.tree.TokenSet;
|
||||
*/
|
||||
public class JavaParserDefinition implements ParserDefinition {
|
||||
public Lexer createLexer() {
|
||||
return null;
|
||||
return new JavaLexer(LanguageLevel.HIGHEST);
|
||||
}
|
||||
|
||||
public IElementType getFileNodeType() {
|
||||
|
||||
@@ -12,21 +12,15 @@ import java.io.IOException;
|
||||
|
||||
public class JavaLexer implements Lexer, Cloneable {
|
||||
|
||||
private JavaLexer(boolean isAssertKeywordEnabled, boolean isJDK15, boolean escapeTokensInXml) {
|
||||
private JavaLexer(boolean isAssertKeywordEnabled, boolean isJDK15) {
|
||||
myTable = isAssertKeywordEnabled ?
|
||||
(isJDK15 ? ourTableWithAssertAndJDK15 : ourTableWithAssert) :
|
||||
(isJDK15 ? ourTableWithJDK15 : ourTableWithoutAssert);
|
||||
myJLexlexer = escapeTokensInXml ?
|
||||
(Lexer)new _XmlEscapedJavaLexer(isAssertKeywordEnabled, isJDK15) :
|
||||
new _JavaLexer(isAssertKeywordEnabled, isJDK15);
|
||||
}
|
||||
|
||||
public JavaLexer(LanguageLevel level, boolean escapeTokensInXml) {
|
||||
this(level.hasAssertKeyword(), level.hasEnumKeywordAndAutoboxing(), escapeTokensInXml);
|
||||
myJLexlexer = new _JavaLexer(isAssertKeywordEnabled, isJDK15);
|
||||
}
|
||||
|
||||
public JavaLexer(LanguageLevel level) {
|
||||
this(level.hasAssertKeyword(), level.hasEnumKeywordAndAutoboxing(), false);
|
||||
this(level.hasAssertKeyword(), level.hasEnumKeywordAndAutoboxing());
|
||||
}
|
||||
|
||||
private char[] myBuffer;
|
||||
|
||||
@@ -792,7 +792,7 @@
|
||||
}
|
||||
case 47: break;
|
||||
case 23:
|
||||
{ myTokenType = XmlTokenType.XML_MARKUP; return;
|
||||
{ myTokenType = XmlElementType.XML_MARKUP; return;
|
||||
}
|
||||
case 48: break;
|
||||
case 9:
|
||||
|
||||
@@ -5,7 +5,7 @@ import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.psi.TokenType;
|
||||
import com.intellij.psi.TokenTypeEx;
|
||||
import com.intellij.psi.impl.source.tree.ElementType;
|
||||
import com.intellij.psi.search.scope.packageSet.*;
|
||||
|
||||
@@ -37,7 +37,7 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
private PackageSet parseUnion() throws ParsingException {
|
||||
PackageSet result = parseIntersection();
|
||||
while (true) {
|
||||
if (myLexer.getTokenType() != TokenType.OROR) break;
|
||||
if (myLexer.getTokenType() != TokenTypeEx.OROR) break;
|
||||
myLexer.advance();
|
||||
result = new UnionPackageSet(result, parseIntersection());
|
||||
}
|
||||
@@ -47,7 +47,7 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
private PackageSet parseIntersection() throws ParsingException {
|
||||
PackageSet result = parseTerm();
|
||||
while (true) {
|
||||
if (myLexer.getTokenType() != TokenType.ANDAND) break;
|
||||
if (myLexer.getTokenType() != TokenTypeEx.ANDAND) break;
|
||||
myLexer.advance();
|
||||
result = new IntersectionPackageSet(result, parseTerm());
|
||||
}
|
||||
@@ -55,13 +55,13 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
}
|
||||
|
||||
private PackageSet parseTerm() throws ParsingException {
|
||||
if (myLexer.getTokenType() == TokenType.EXCL) {
|
||||
if (myLexer.getTokenType() == TokenTypeEx.EXCL) {
|
||||
myLexer.advance();
|
||||
return new ComplementPackageSet(parseTerm());
|
||||
}
|
||||
|
||||
if (myLexer.getTokenType() == TokenType.LPARENTH) return parseParenthesized();
|
||||
if (myLexer.getTokenType() == TokenType.IDENTIFIER && myLexer.getBuffer()[myLexer.getTokenStart()] == '$') {
|
||||
if (myLexer.getTokenType() == TokenTypeEx.LPARENTH) return parseParenthesized();
|
||||
if (myLexer.getTokenType() == TokenTypeEx.IDENTIFIER && myLexer.getBuffer()[myLexer.getTokenStart()] == '$') {
|
||||
NamedPackageSetReference namedPackageSetReference = new NamedPackageSetReference(getTokenText());
|
||||
myLexer.advance();
|
||||
return namedPackageSetReference;
|
||||
@@ -73,7 +73,7 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
String scope = parseScope();
|
||||
String modulePattern = parseModulePattern();
|
||||
|
||||
if (myLexer.getTokenType() == TokenType.COLON) {
|
||||
if (myLexer.getTokenType() == TokenTypeEx.COLON) {
|
||||
if (scope == PatternPackageSet.SCOPE_ANY && modulePattern == null) {
|
||||
error("(test|lib|src)[modulename] expected before :");
|
||||
}
|
||||
@@ -86,7 +86,7 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
}
|
||||
|
||||
private String parseScope() {
|
||||
if (myLexer.getTokenType() != TokenType.IDENTIFIER) return PatternPackageSet.SCOPE_ANY;
|
||||
if (myLexer.getTokenType() != TokenTypeEx.IDENTIFIER) return PatternPackageSet.SCOPE_ANY;
|
||||
String id = getTokenText();
|
||||
String scope = PatternPackageSet.SCOPE_ANY;
|
||||
if (PatternPackageSet.SCOPE_SOURCE.equals(id)) {
|
||||
@@ -116,15 +116,15 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
StringBuffer pattern = new StringBuffer();
|
||||
boolean wasIdentifier = false;
|
||||
while (true) {
|
||||
if (myLexer.getTokenType() == TokenType.DOT) {
|
||||
if (myLexer.getTokenType() == TokenTypeEx.DOT) {
|
||||
pattern.append('.');
|
||||
wasIdentifier = false;
|
||||
}
|
||||
else if (myLexer.getTokenType() == TokenType.ASTERISK) {
|
||||
else if (myLexer.getTokenType() == TokenTypeEx.ASTERISK) {
|
||||
pattern.append('*');
|
||||
wasIdentifier = false;
|
||||
}
|
||||
else if (myLexer.getTokenType() == TokenType.IDENTIFIER) {
|
||||
else if (myLexer.getTokenType() == TokenTypeEx.IDENTIFIER) {
|
||||
if (wasIdentifier) error("Unexpected " + getTokenText());
|
||||
wasIdentifier = true;
|
||||
pattern.append(getTokenText());
|
||||
@@ -149,16 +149,16 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
}
|
||||
|
||||
private String parseModulePattern() throws ParsingException {
|
||||
if (myLexer.getTokenType() != TokenType.LBRACKET) return null;
|
||||
if (myLexer.getTokenType() != TokenTypeEx.LBRACKET) return null;
|
||||
myLexer.advance();
|
||||
StringBuffer pattern = new StringBuffer();
|
||||
while (true) {
|
||||
if (myLexer.getTokenType() == TokenType.RBRACKET) {
|
||||
if (myLexer.getTokenType() == TokenTypeEx.RBRACKET) {
|
||||
myLexer.advance();
|
||||
break;
|
||||
}
|
||||
|
||||
if (myLexer.getTokenType() == TokenType.IDENTIFIER || myLexer.getTokenType() == TokenType.ASTERISK) {
|
||||
if (myLexer.getTokenType() == TokenTypeEx.IDENTIFIER || myLexer.getTokenType() == TokenTypeEx.ASTERISK) {
|
||||
pattern.append(getTokenText());
|
||||
myLexer.advance();
|
||||
}
|
||||
@@ -170,11 +170,11 @@ public class PackageSetFactoryImpl extends PackageSetFactory {
|
||||
}
|
||||
|
||||
private PackageSet parseParenthesized() throws ParsingException {
|
||||
LOG.assertTrue(myLexer.getTokenType() == TokenType.LPARENTH);
|
||||
LOG.assertTrue(myLexer.getTokenType() == TokenTypeEx.LPARENTH);
|
||||
myLexer.advance();
|
||||
|
||||
PackageSet result = parseUnion();
|
||||
if (myLexer.getTokenType() != TokenType.RPARENTH) error("')' expected");
|
||||
if (myLexer.getTokenType() != TokenTypeEx.RPARENTH) error("')' expected");
|
||||
myLexer.advance();
|
||||
|
||||
return result;
|
||||
|
||||
@@ -27,6 +27,8 @@ import com.intellij.openapi.vfs.VirtualFile;
|
||||
import com.intellij.packageDependencies.packageSet.PackageSetFactoryImpl;
|
||||
import com.intellij.peer.PeerFactory;
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.impl.source.tree.SharedImplUtil;
|
||||
import com.intellij.psi.impl.source.tree.LeafElement;
|
||||
import com.intellij.psi.search.scope.packageSet.PackageSetFactory;
|
||||
import com.intellij.psi.util.PsiFormatUtil;
|
||||
import com.intellij.ui.*;
|
||||
@@ -40,6 +42,11 @@ import com.intellij.util.EditSourceOnEnterKeyHandler;
|
||||
import com.intellij.util.ui.Table;
|
||||
import com.intellij.util.ui.Tree;
|
||||
import com.intellij.util.ui.treetable.TreeTable;
|
||||
import com.intellij.lang.PsiBuilder;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.Language;
|
||||
import com.intellij.lang.impl.PsiBuilderImpl;
|
||||
import com.intellij.lexer.Lexer;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.table.TableCellRenderer;
|
||||
@@ -231,4 +238,12 @@ public class PeerFactoryImpl extends PeerFactory implements ApplicationComponent
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public PsiBuilder createBuilder(ASTNode tree, Language lang, CharSequence seq) {
|
||||
final Lexer lexer = lang.getParserDefinition().createLexer();
|
||||
lexer.start(((LeafElement)tree).textToCharArray());
|
||||
return new PsiBuilderImpl(lexer, SharedImplUtil.findCharTableByTree(tree),
|
||||
false, lang.getParserDefinition().getWhitespaceTokens(),
|
||||
lang.getParserDefinition().getCommentTokens());
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,7 @@ import java.util.*;
|
||||
*/
|
||||
public class TreeChangeEventImpl implements TreeChangeEvent{
|
||||
private final Map<ASTNode, TreeChange> myChangedElements = new HashMap<ASTNode, TreeChange>();
|
||||
private final List<ASTNode> myChangedInOrder = new ArrayList<ASTNode>();
|
||||
private final List<Set<ASTNode>> myOfEqualDepth = new ArrayList<Set<ASTNode>>(10);
|
||||
private final PomModelAspect myAspect;
|
||||
private final FileElement myFileElement;
|
||||
@@ -36,7 +37,7 @@ public class TreeChangeEventImpl implements TreeChangeEvent{
|
||||
|
||||
public TreeElement[] getChangedElements() {
|
||||
final TreeElement[] ret = new TreeElement[myChangedElements.size()];
|
||||
final Iterator<ASTNode> iterator = myChangedElements.keySet().iterator();
|
||||
final Iterator<ASTNode> iterator = myChangedInOrder.iterator();
|
||||
int index = 0;
|
||||
while (iterator.hasNext()) {
|
||||
ret[index++] = (TreeElement)iterator.next();
|
||||
@@ -72,8 +73,8 @@ public class TreeChangeEventImpl implements TreeChangeEvent{
|
||||
prevParent = currentParent;
|
||||
currentParent = currentParent.getTreeParent();
|
||||
}
|
||||
processElementaryChange(parent, element, change, depth - 1);
|
||||
compactChanges(parent, depth - 1);
|
||||
processElementaryChange(parent, element, change, depth - 1);
|
||||
}
|
||||
|
||||
private int getDepth(ASTNode element) {
|
||||
@@ -92,6 +93,8 @@ public class TreeChangeEventImpl implements TreeChangeEvent{
|
||||
if(treeChange == null){
|
||||
treeChange = new TreeChangeImpl(parent);
|
||||
myChangedElements.put(parent, treeChange);
|
||||
insertAtList(parent);
|
||||
|
||||
final int index = depth >= 0 ? depth : getDepth(parent);
|
||||
Set<ASTNode> treeElements = index < myOfEqualDepth.size() ? myOfEqualDepth.get(index) : null;
|
||||
if(treeElements == null){
|
||||
@@ -133,7 +136,7 @@ public class TreeChangeEventImpl implements TreeChangeEvent{
|
||||
compactedChange.compactChange(treeElement, getChangesByElement(treeElement));
|
||||
|
||||
iterator.remove();
|
||||
myChangedElements.remove(treeElement);
|
||||
removeAssociatedChanges(treeElement, currentDepth);
|
||||
final CompositeElement treeParent = treeElement.getTreeParent();
|
||||
final TreeChange changesByElement = getChangesByElement(treeParent);
|
||||
if (changesByElement != null) {
|
||||
@@ -154,14 +157,64 @@ public class TreeChangeEventImpl implements TreeChangeEvent{
|
||||
}
|
||||
|
||||
private void removeAssociatedChanges(ASTNode treeElement, int depth) {
|
||||
if(myChangedElements.remove(treeElement) != null){
|
||||
if(depth < 0) depth = getDepth(treeElement);
|
||||
if(myChangedElements.remove(treeElement) != null) {
|
||||
myChangedInOrder.remove(treeElement);
|
||||
if (depth < 0) depth = getDepth(treeElement);
|
||||
if (depth < myOfEqualDepth.size()) {
|
||||
myOfEqualDepth.get(depth < 0 ? getDepth(treeElement) : depth).remove(treeElement);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void insertAtList(ASTNode node){
|
||||
final int[] nodeRoute = getRoute(node);
|
||||
int index = 0;
|
||||
while(index < myChangedInOrder.size()){
|
||||
final ASTNode current = myChangedInOrder.get(index++);
|
||||
final int[] route = getRoute(current);
|
||||
if(compareRouts(nodeRoute, route) < 0) {
|
||||
myChangedInOrder.add(index, node);
|
||||
return;
|
||||
}
|
||||
}
|
||||
myChangedInOrder.add(node);
|
||||
}
|
||||
|
||||
private int[] getRoute(ASTNode node){
|
||||
final List<ASTNode> parents = new ArrayList<ASTNode>(20);
|
||||
while(node != null){
|
||||
parents.add(node);
|
||||
node = node.getTreeParent();
|
||||
}
|
||||
final int[] root = new int[parents.size() - 1];
|
||||
for(int i = 0; i < root.length; i++){
|
||||
final ASTNode parent = parents.get(root.length - i - 1);
|
||||
int rootIndex = 0;
|
||||
ASTNode current = parent.getTreeParent().getFirstChildNode();
|
||||
while(current != parent){
|
||||
current = current.getTreeNext();
|
||||
rootIndex++;
|
||||
}
|
||||
root[i] = rootIndex;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
|
||||
private int compareRouts(int[] root1, int[] root2){
|
||||
final int depth = Math.min(root1.length, root2.length);
|
||||
for(int i = 0; i < depth; i++){
|
||||
if(root1[i] == root2[i]) continue;
|
||||
if(root1[i] > root2[i]){
|
||||
return 1;
|
||||
}
|
||||
else if(root2[i] > root1[i]){
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if(root1.length == root2.length) return 0;
|
||||
if(root1.length < root2.length) return 1;
|
||||
return -1;
|
||||
}
|
||||
|
||||
public PomModelAspect getAspect() {
|
||||
return myAspect;
|
||||
|
||||
@@ -5,13 +5,16 @@ import com.intellij.pom.tree.events.ChangeInfo;
|
||||
import com.intellij.pom.tree.events.ReplaceChangeInfo;
|
||||
import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.openapi.util.Pair;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.util.CharTable;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class TreeChangeImpl implements TreeChange {
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.events.impl.TreeChangeImpl");
|
||||
private final Map<ASTNode, ChangeInfo> myChanges = new LinkedHashMap<ASTNode, ChangeInfo>();
|
||||
private final Map<ASTNode, ChangeInfo> myChanges = new HashMap<ASTNode, ChangeInfo>();
|
||||
private final List<Pair<ASTNode,Integer>> myOffsets = new ArrayList<Pair<ASTNode, Integer>>();
|
||||
private final ASTNode myParent;
|
||||
|
||||
public TreeChangeImpl(ASTNode parent) {
|
||||
@@ -34,7 +37,7 @@ public class TreeChangeImpl implements TreeChange {
|
||||
|
||||
if(replacedInfo == null){
|
||||
//myChanges.put(replaced, ChangeInfo.create(ChangeInfo.REMOVED, replaced, SharedImplUtil.findCharTableByTree(myParent)));
|
||||
myChanges.put(child, changeInfo);
|
||||
addChangeInternal(child, changeInfo);
|
||||
}
|
||||
else{
|
||||
switch(replacedInfo.getChangeType()){
|
||||
@@ -44,24 +47,24 @@ public class TreeChangeImpl implements TreeChange {
|
||||
break;
|
||||
case ChangeInfo.ADD:
|
||||
changeInfo = ChangeInfoImpl.create(ChangeInfo.ADD, replaced, SharedImplUtil.findCharTableByTree(myParent));
|
||||
myChanges.remove(replaced);
|
||||
removeChangeInternal(child);
|
||||
break;
|
||||
}
|
||||
myChanges.put(child, changeInfo);
|
||||
addChangeInternal(child, changeInfo);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if(current != null && current.getChangeType() == ChangeInfo.REMOVED){
|
||||
if(changeInfo.getChangeType() == ChangeInfo.ADD){
|
||||
myChanges.remove(child);
|
||||
removeChangeInternal(child);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if(current != null && current.getChangeType() == ChangeInfo.ADD){
|
||||
if(changeInfo.getChangeType() == ChangeInfo.REMOVED){
|
||||
myChanges.remove(child);
|
||||
removeChangeInternal(child);
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -71,24 +74,52 @@ public class TreeChangeImpl implements TreeChange {
|
||||
final int charTabIndex = ((LeafElement)child).getCharTabIndex();
|
||||
if(checkLeaf(child.getTreeNext(), charTabIndex) || checkLeaf(child.getTreePrev(), charTabIndex)) return;
|
||||
}
|
||||
myChanges.put(child, changeInfo);
|
||||
if(current != null)
|
||||
addChangeInternal(child, changeInfo);
|
||||
if (current != null) {
|
||||
((ChangeInfoImpl)changeInfo).setOldLength(current.getOldLength());
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if(current == null){
|
||||
myChanges.put(child, changeInfo);
|
||||
addChangeInternal(child, changeInfo);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
private void addChangeInternal(ASTNode child, ChangeInfo info){
|
||||
myChanges.put(child, info);
|
||||
final int nodeOffset = getNodeOffset(child);
|
||||
final int n = myOffsets.size();
|
||||
for(int i = 0; i < n; i++){
|
||||
final Pair<ASTNode, Integer> pair = myOffsets.get(i);
|
||||
if(child == pair.getFirst()) return;
|
||||
if(nodeOffset < pair.getSecond().intValue()){
|
||||
myOffsets.add(i, new Pair<ASTNode, Integer>(child, new Integer(nodeOffset)));
|
||||
return;
|
||||
}
|
||||
}
|
||||
myOffsets.add(new Pair<ASTNode, Integer>(child, new Integer(nodeOffset)));
|
||||
}
|
||||
|
||||
private void removeChangeInternal(ASTNode child){
|
||||
myChanges.remove(child);
|
||||
final int n = myOffsets.size();
|
||||
for(int i = 0; i < n; i++){
|
||||
if(child == myOffsets.get(i).getFirst()){
|
||||
myOffsets.remove(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private boolean checkLeaf(final ASTNode treeNext, final int charTabIndex) {
|
||||
if(!(treeNext instanceof LeafElement)) return false;
|
||||
final ChangeInfo right = myChanges.get(treeNext);
|
||||
if(right != null && right.getChangeType() == ChangeInfo.ADD){
|
||||
if(charTabIndex == ((LeafElement)treeNext).getCharTabIndex()){
|
||||
myChanges.remove(treeNext);
|
||||
removeChangeInternal(treeNext);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -96,7 +127,14 @@ public class TreeChangeImpl implements TreeChange {
|
||||
}
|
||||
|
||||
public TreeElement[] getAffectedChildren() {
|
||||
return myChanges.keySet().toArray(new TreeElement[myChanges.size()]);
|
||||
final TreeElement[] treeElements = new TreeElement[myChanges.size()];
|
||||
int index = 0;
|
||||
final Iterator<Pair<ASTNode, Integer>> iterator = myOffsets.iterator();
|
||||
while(iterator.hasNext()){
|
||||
final Pair<ASTNode, Integer> pair = iterator.next();
|
||||
treeElements[index++] = (TreeElement)pair.getFirst();
|
||||
}
|
||||
return treeElements;
|
||||
}
|
||||
|
||||
public ChangeInfo getChangeByChild(ASTNode child) {
|
||||
@@ -118,7 +156,30 @@ public class TreeChangeImpl implements TreeChange {
|
||||
}
|
||||
|
||||
public void removeChange(ASTNode beforeEqualDepth) {
|
||||
myChanges.remove(beforeEqualDepth);
|
||||
removeChangeInternal(beforeEqualDepth);
|
||||
}
|
||||
|
||||
private int getNodeOffset(ASTNode child){
|
||||
LOG.assertTrue(child.getTreeParent() == myParent);
|
||||
final CharTable table = SharedImplUtil.findCharTableByTree(myParent);
|
||||
ASTNode current = myParent.getFirstChildNode();
|
||||
final Iterator<Pair<ASTNode, Integer>> iterator = myOffsets.iterator();
|
||||
Pair<ASTNode, Integer> currentChange = iterator.hasNext() ? iterator.next() : null;
|
||||
int currentOffset = 0;
|
||||
do{
|
||||
boolean counted = false;
|
||||
while(currentChange != null && currentOffset == currentChange.getSecond().intValue()){
|
||||
if(current == currentChange.getFirst()) counted = true;
|
||||
final ChangeInfo changeInfo = myChanges.get(currentChange.getFirst());
|
||||
currentOffset += changeInfo.getOldLength();
|
||||
currentChange = iterator.hasNext() ? iterator.next() : null;
|
||||
}
|
||||
if(current == child) break;
|
||||
if(!counted) currentOffset += ((TreeElement)current).getTextLength(table);
|
||||
current = current.getTreeNext();
|
||||
}
|
||||
while(true);
|
||||
return currentOffset;
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
* Copyright (c) 2000-2004 by JetBrains s.r.o. All Rights Reserved.
|
||||
* Use is subject to license terms.
|
||||
*/
|
||||
package com.intellij.psi;
|
||||
|
||||
import com.intellij.psi.jsp.JspTokenType;
|
||||
import com.intellij.psi.xml.DTDTokenType;
|
||||
import com.intellij.psi.xml.XmlTokenType;
|
||||
|
||||
public interface TokenTypeEx extends
|
||||
TokenType,
|
||||
JavaTokenType,
|
||||
JavaDocTokenType,
|
||||
JspTokenType,
|
||||
XmlTokenType,
|
||||
DTDTokenType,
|
||||
com.intellij.aspects.psi.gen.TokenType {
|
||||
}
|
||||
@@ -3,6 +3,7 @@ package com.intellij.psi.filters;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.jsp.JspToken;
|
||||
import com.intellij.psi.jsp.JspTokenType;
|
||||
import com.intellij.psi.filters.classes.AnyInnerFilter;
|
||||
import com.intellij.psi.filters.classes.InheritorFilter;
|
||||
import com.intellij.psi.filters.classes.InterfaceFilter;
|
||||
@@ -177,7 +178,7 @@ public class FilterUtil{
|
||||
if (offset < 0) return null;
|
||||
element = element.getContainingFile().findElementAt(offset);
|
||||
if (element == null) return null;
|
||||
if(element instanceof JspToken && ((JspToken)element).getTokenType() == JspToken.JSP_DIRECTIVE_WHITE_SPACE) continue;
|
||||
if(element instanceof JspToken && ((JspToken)element).getTokenType() == JspTokenType.JSP_DIRECTIVE_WHITE_SPACE) continue;
|
||||
if (!(element instanceof PsiWhiteSpace) && !(element instanceof PsiComment)) return element;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -76,7 +76,7 @@ public class DebugUtil {
|
||||
buffer.append(' ');
|
||||
}
|
||||
if (root instanceof CompositeElement) {
|
||||
final PsiElement psiElement = treeElementToPsi(root);
|
||||
final PsiElement psiElement = root.getPsi();
|
||||
if (psiElement != null) {
|
||||
buffer.append(psiElement.toString());
|
||||
}
|
||||
@@ -130,7 +130,7 @@ public class DebugUtil {
|
||||
}
|
||||
buffer.append(root.getUserDataString());
|
||||
buffer.append("\n");
|
||||
if (root instanceof CompositeElement || root instanceof ChameleonElement) {
|
||||
if (root instanceof CompositeElement || ((LeafElement)root).isChameleon()) {
|
||||
PsiElement[] children = SourceTreeToPsiMap.treeElementToPsi(root).getChildren();
|
||||
|
||||
for (int i = 0; i < children.length; i++) {
|
||||
|
||||
@@ -4,8 +4,11 @@ import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiElementVisitor;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.impl.source.tree.ElementType;
|
||||
import com.intellij.psi.PsiJavaToken;
|
||||
import com.intellij.psi.impl.source.tree.ElementType;
|
||||
import com.intellij.psi.impl.source.tree.JavaDocElementType;
|
||||
import com.intellij.psi.impl.source.tree.TreeElement;
|
||||
import com.intellij.psi.javadoc.PsiDocComment;
|
||||
import com.intellij.psi.javadoc.PsiDocTag;
|
||||
@@ -38,7 +41,7 @@ class ClsDocCommentImpl extends ClsElementImpl implements PsiDocComment, JavaTok
|
||||
|
||||
public void setMirror(TreeElement element) {
|
||||
LOG.assertTrue(myMirror == null);
|
||||
LOG.assertTrue(element.getElementType() == ElementType.DOC_COMMENT);
|
||||
LOG.assertTrue(element.getElementType() == JavaDocElementType.DOC_COMMENT);
|
||||
myMirror = element;
|
||||
}
|
||||
|
||||
@@ -73,11 +76,11 @@ class ClsDocCommentImpl extends ClsElementImpl implements PsiDocComment, JavaTok
|
||||
}
|
||||
|
||||
public IElementType getTokenType() {
|
||||
return JavaTokenType.DOC_COMMENT;
|
||||
return JavaDocElementType.DOC_COMMENT;
|
||||
}
|
||||
|
||||
public void accept(PsiElementVisitor visitor) {
|
||||
visitor.visitDocComment(this);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,6 @@ import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiLock;
|
||||
import com.intellij.psi.impl.source.SourceTreeToPsiMap;
|
||||
import com.intellij.psi.impl.source.parsing.ChameleonTransforming;
|
||||
import com.intellij.psi.impl.source.tree.ChameleonElement;
|
||||
import com.intellij.psi.impl.source.tree.CompositeElement;
|
||||
import com.intellij.psi.impl.source.tree.LeafElement;
|
||||
import com.intellij.psi.search.PsiElementProcessor;
|
||||
@@ -101,11 +100,11 @@ public class LowLevelSearchUtil {
|
||||
synchronized (PsiLock.LOCK) {
|
||||
ASTNode child = scope.getFirstChildNode();
|
||||
while (child != null) {
|
||||
if (child instanceof ChameleonElement) {
|
||||
if (child instanceof LeafElement && ((LeafElement)child).isChameleon()) {
|
||||
LeafElement leaf = (LeafElement)child;
|
||||
if (leaf.searchWord(0, searcher) >= 0) {
|
||||
ASTNode next = child.getTreeNext();
|
||||
child = ChameleonTransforming.transform((ChameleonElement)child);
|
||||
child = ChameleonTransforming.transform((LeafElement)child);
|
||||
if (child == null) {
|
||||
child = next;
|
||||
}
|
||||
@@ -120,7 +119,7 @@ public class LowLevelSearchUtil {
|
||||
while (true) {
|
||||
synchronized (PsiLock.LOCK) {
|
||||
child = child != null ? child.getTreeNext() : scope.getFirstChildNode();
|
||||
while (child instanceof ChameleonElement) {
|
||||
while (child instanceof LeafElement && ((LeafElement)child).isChameleon()) {
|
||||
child = child.getTreeNext();
|
||||
}
|
||||
if (child == null) break;
|
||||
|
||||
@@ -171,7 +171,7 @@ public class PsiCodeFragmentImpl extends PsiFileImpl implements PsiCodeFragment,
|
||||
|
||||
|
||||
IElementType i = myContentElementType;
|
||||
if (i == ElementType.TYPE_TEXT || i == ElementType.EXPRESSION_TEXT || i == ElementType.REFERENCE_TEXT) {
|
||||
if (i == ElementType.TYPE_TEXT || i == ElementType.EXPRESSION_STATEMENT || i == ElementType.REFERENCE_TEXT) {
|
||||
return true;
|
||||
} else {
|
||||
{
|
||||
|
||||
@@ -5,7 +5,7 @@ import com.intellij.openapi.project.Project;
|
||||
import com.intellij.psi.PsiExpression;
|
||||
import com.intellij.psi.PsiExpressionCodeFragment;
|
||||
import com.intellij.psi.impl.source.parsing.ChameleonTransforming;
|
||||
import com.intellij.psi.impl.source.tree.ElementType;
|
||||
import com.intellij.psi.impl.source.tree.JavaElementType;
|
||||
import com.intellij.psi.impl.source.tree.TreeUtil;
|
||||
|
||||
public class PsiExpressionCodeFragmentImpl extends PsiCodeFragmentImpl implements PsiExpressionCodeFragment {
|
||||
@@ -13,7 +13,7 @@ public class PsiExpressionCodeFragmentImpl extends PsiCodeFragmentImpl implement
|
||||
boolean isPhysical,
|
||||
String name,
|
||||
CharSequence text) {
|
||||
super(project, ElementType.EXPRESSION_TEXT, isPhysical, name, text);
|
||||
super(project, JavaElementType.EXPRESSION_STATEMENT, isPhysical, name, text);
|
||||
}
|
||||
|
||||
public PsiExpression getExpression() {
|
||||
|
||||
@@ -64,12 +64,14 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme
|
||||
return myKindWhenDummy;
|
||||
}
|
||||
else if (i == TYPE || i == EXTENDS_LIST || i == IMPLEMENTS_LIST || i == EXTENDS_BOUND_LIST || i == THROWS_LIST ||
|
||||
i == THIS_EXPRESSION ||
|
||||
i == SUPER_EXPRESSION ||
|
||||
i == DOC_METHOD_OR_FIELD_REF ||
|
||||
i == DOC_TAG_VALUE_TOKEN ||
|
||||
i == REFERENCE_PARAMETER_LIST ||
|
||||
i == ANNOTATION) {
|
||||
i == THIS_EXPRESSION ||
|
||||
i == SUPER_EXPRESSION ||
|
||||
i == DOC_METHOD_OR_FIELD_REF ||
|
||||
i == DOC_REFERENCE_HOLDER ||
|
||||
i == DOC_TYPE_HOLDER ||
|
||||
i == DOC_TAG_VALUE_TOKEN ||
|
||||
i == REFERENCE_PARAMETER_LIST ||
|
||||
i == ANNOTATION) {
|
||||
return CLASS_NAME_KIND;
|
||||
}
|
||||
else if (i == NEW_EXPRESSION) {
|
||||
@@ -133,7 +135,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme
|
||||
else if (i == IMPORT_STATIC_REFERENCE) {
|
||||
return CLASS_FQ_OR_PACKAGE_NAME_KIND;
|
||||
}
|
||||
else if (i == DOC_TAG || i == DOC_INLINE_TAG) {
|
||||
else if (i == DOC_TAG || i == DOC_INLINE_TAG || i == DOC_REFERENCE_HOLDER || i == DOC_TYPE_HOLDER) {
|
||||
return CLASS_OR_PACKAGE_NAME_KIND;
|
||||
}
|
||||
else if (i == CODE_FRAGMENT) {
|
||||
|
||||
@@ -10,11 +10,11 @@ import com.intellij.psi.PsiManager;
|
||||
|
||||
public class PsiJavaFileImpl extends PsiJavaFileBaseImpl {
|
||||
public PsiJavaFileImpl(Project project, VirtualFile file) {
|
||||
super(project, JAVA_FILE, JAVA_FILE_TEXT, file);
|
||||
super(project, JAVA_FILE, JAVA_FILE, file);
|
||||
}
|
||||
|
||||
public PsiJavaFileImpl(Project project, String name, CharSequence text) {
|
||||
super(project, JAVA_FILE, JAVA_FILE_TEXT, name, text);
|
||||
super(project, JAVA_FILE, JAVA_FILE, name, text);
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
|
||||
@@ -182,7 +182,7 @@ public class PsiMethodImpl extends NonSlaveRepositoryPsiElement implements PsiMe
|
||||
if (i == LBRACKET) {
|
||||
arrayCount++;
|
||||
}
|
||||
else if (i == RBRACKET || i == WHITE_SPACE || i == C_STYLE_COMMENT || i == DOC_COMMENT || i == END_OF_LINE_COMMENT) {
|
||||
else if (i == RBRACKET || i == WHITE_SPACE || i == C_STYLE_COMMENT || i == JavaDocElementType.DOC_COMMENT || i == END_OF_LINE_COMMENT) {
|
||||
}
|
||||
else {
|
||||
break Loop;
|
||||
|
||||
@@ -273,7 +273,7 @@ public class CodeStyleManagerImpl extends CodeStyleManagerEx implements ProjectC
|
||||
ASTNode next = element.getTreeNext();
|
||||
ASTNode space1 = Helper.splitSpaceElement((TreeElement)element, end - spaceStart, charTable);
|
||||
ASTNode tempElement = Factory.createSingleLeafElement(
|
||||
TokenType.NEW_LINE_INDENT, "xxx".toCharArray(), 0,
|
||||
TokenTypeEx.NEW_LINE_INDENT, "xxx".toCharArray(), 0,
|
||||
"xxx".length(), charTable, null);
|
||||
parent.addChild(tempElement, space1.getTreeNext());
|
||||
tempElement = new IndentAdjusterFacade(getSettings(), helper).adjustIndent(tempElement);
|
||||
@@ -374,7 +374,7 @@ public class CodeStyleManagerImpl extends CodeStyleManagerEx implements ProjectC
|
||||
}
|
||||
|
||||
ASTNode space1 = Helper.splitSpaceElement((TreeElement)element, offset - elementStart, charTable);
|
||||
ASTNode marker = Factory.createSingleLeafElement(TokenType.NEW_LINE_INDENT, "###".toCharArray(), 0, "###".length(), charTable, null);
|
||||
ASTNode marker = Factory.createSingleLeafElement(TokenTypeEx.NEW_LINE_INDENT, "###".toCharArray(), 0, "###".length(), charTable, null);
|
||||
parent.addChild(marker, space1.getTreeNext());
|
||||
return SourceTreeToPsiMap.treeElementToPsi(marker);
|
||||
}
|
||||
|
||||
@@ -49,7 +49,7 @@ class ReferenceAdjuster implements Constants {
|
||||
}
|
||||
|
||||
if (rightKind) {
|
||||
boolean isInsideDocComment = TreeUtil.findParent(element, ElementType.DOC_COMMENT) != null;
|
||||
boolean isInsideDocComment = TreeUtil.findParent(element, JavaDocElementType.DOC_COMMENT) != null;
|
||||
boolean isShort = !((SourceJavaCodeReference)element).isQualified();
|
||||
if (!makeFQ(isInsideDocComment)) {
|
||||
if (isShort) return element; // short name already, no need to change
|
||||
|
||||
@@ -19,7 +19,7 @@ import com.intellij.psi.xml.XmlElementType;
|
||||
*/
|
||||
public class HtmlFileImpl extends XmlFileImpl {
|
||||
public HtmlFileImpl(Project project, VirtualFile file) {
|
||||
super(project, file, XmlElementType.HTML_FILE, XmlElementType.HTML_FILE_TEXT);
|
||||
super(project, file, XmlElementType.HTML_FILE, XmlElementType.HTML_FILE);
|
||||
}
|
||||
|
||||
public HtmlFileImpl(Project project, String name, CharSequence text, FileType fileType) {
|
||||
|
||||
@@ -2,9 +2,7 @@ package com.intellij.psi.impl.source.javadoc;
|
||||
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lexer.JavaDocLexer;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiElementVisitor;
|
||||
@@ -22,7 +20,7 @@ import com.intellij.util.text.CharArrayCharSequence;
|
||||
import java.util.ArrayList;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
public class PsiDocCommentImpl extends CompositePsiElement implements PsiDocComment, JavaTokenType, Reparseable, PsiJavaToken {
|
||||
public class PsiDocCommentImpl extends CompositePsiElement implements PsiDocComment, JavaTokenType {
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.javadoc.PsiDocCommentImpl");
|
||||
|
||||
private static final TokenSet TAG_BIT_SET = TokenSet.create(new IElementType[]{DOC_TAG});
|
||||
@@ -35,7 +33,7 @@ public class PsiDocCommentImpl extends CompositePsiElement implements PsiDocComm
|
||||
|
||||
|
||||
public PsiDocCommentImpl() {
|
||||
super(DOC_COMMENT);
|
||||
super(JavaDocElementType.DOC_COMMENT);
|
||||
}
|
||||
|
||||
public PsiElement[] getDescriptionElements() {
|
||||
@@ -56,7 +54,7 @@ public class PsiDocCommentImpl extends CompositePsiElement implements PsiDocComm
|
||||
}
|
||||
|
||||
public PsiDocTag findTagByName(String name) {
|
||||
if (getFirstChildNode().getElementType() == DOC_COMMENT_TEXT) {
|
||||
if (getFirstChildNode().getElementType() == JavaDocElementType.DOC_COMMENT) {
|
||||
if (getFirstChildNode().getText().indexOf(name) < 0) return null;
|
||||
}
|
||||
|
||||
@@ -246,7 +244,7 @@ public class PsiDocCommentImpl extends CompositePsiElement implements PsiDocComm
|
||||
if (i == DOC_TAG) {
|
||||
return ChildRole.DOC_TAG;
|
||||
}
|
||||
else if (i == DOC_COMMENT_TEXT || i == DOC_INLINE_TAG) {
|
||||
else if (i == JavaDocElementType.DOC_COMMENT || i == DOC_INLINE_TAG) {
|
||||
return ChildRole.DOC_CONTENT;
|
||||
}
|
||||
else if (i == DOC_COMMENT_LEADING_ASTERISKS) {
|
||||
@@ -271,20 +269,7 @@ public class PsiDocCommentImpl extends CompositePsiElement implements PsiDocComm
|
||||
return "PsiDocComment";
|
||||
}
|
||||
|
||||
public ChameleonElement createChameleon(char[] buffer, int start, int end) {
|
||||
return new DocCommentChameleonElement(buffer, start, end, -1, SharedImplUtil.findCharTableByTree(this));
|
||||
}
|
||||
|
||||
public int getErrorsCount(char[] buffer, int start, int end, int lengthShift) {
|
||||
final JavaLexer lexer = new JavaLexer(LanguageLevel.JDK_1_5);
|
||||
lexer.start(buffer, start, end);
|
||||
if(lexer.getTokenType() != DOC_COMMENT_TEXT) return -1;
|
||||
lexer.advance();
|
||||
if(lexer.getTokenType() != null) return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
public Class getLexerClass() {
|
||||
return JavaDocLexer.class;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -136,8 +136,9 @@ public class PsiDocMethodOrFieldRef extends CompositePsiElement implements PsiDo
|
||||
|
||||
private PsiElement getScope(){
|
||||
ChameleonTransforming.transformChildren(this);
|
||||
if (getFirstChildNode().getElementType() == ElementType.JAVA_CODE_REFERENCE || getFirstChildNode().getElementType() == ElementType.REFERENCE_EXPRESSION) {
|
||||
PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)SourceTreeToPsiMap.treeElementToPsi(getFirstChildNode());
|
||||
if (getFirstChildNode().getElementType() == ElementType.DOC_REFERENCE_HOLDER) {
|
||||
PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)SourceTreeToPsiMap.treeElementToPsi(getFirstChildNode().getFirstChildNode());
|
||||
if(referenceElement == null) return null;
|
||||
final PsiElement referencedElement = referenceElement.resolve();
|
||||
if (referencedElement instanceof PsiClass) {
|
||||
return referencedElement;
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.intellij.psi.impl.source.javadoc;
|
||||
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiElementVisitor;
|
||||
@@ -7,14 +8,13 @@ import com.intellij.psi.impl.SharedPsiElementImplUtil;
|
||||
import com.intellij.psi.impl.source.SourceTreeToPsiMap;
|
||||
import com.intellij.psi.impl.source.tree.ChildRole;
|
||||
import com.intellij.psi.impl.source.tree.CompositePsiElement;
|
||||
import com.intellij.psi.impl.source.tree.TreeElement;
|
||||
import com.intellij.psi.impl.source.tree.JavaDocElementType;
|
||||
import com.intellij.psi.javadoc.PsiDocComment;
|
||||
import com.intellij.psi.javadoc.PsiDocTag;
|
||||
import com.intellij.psi.javadoc.PsiDocTagValue;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.TokenSet;
|
||||
import com.intellij.util.IncorrectOperationException;
|
||||
import com.intellij.lang.ASTNode;
|
||||
|
||||
public class PsiDocTagImpl extends CompositePsiElement implements PsiDocTag {
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.javadoc.PsiDocTagImpl");
|
||||
@@ -64,7 +64,7 @@ public class PsiDocTagImpl extends CompositePsiElement implements PsiDocTag {
|
||||
if (i == DOC_TAG_NAME) {
|
||||
return ChildRole.DOC_TAG_NAME;
|
||||
}
|
||||
else if (i == DOC_COMMENT_TEXT || i == DOC_INLINE_TAG) {
|
||||
else if (i == JavaDocElementType.DOC_COMMENT || i == DOC_INLINE_TAG) {
|
||||
return ChildRole.DOC_CONTENT;
|
||||
}
|
||||
else if (i == DOC_COMMENT_LEADING_ASTERISKS) {
|
||||
|
||||
@@ -15,7 +15,9 @@ import com.intellij.psi.impl.source.tree.*;
|
||||
public class ChameleonTransforming implements Constants {
|
||||
private static final Logger LOG = Logger.getInstance("com.intellij.psi.impl.source.parsing.ChameleonTransforming");
|
||||
|
||||
public static TreeElement transform(ChameleonElement chameleon) {
|
||||
public static ASTNode transform(LeafElement leaf) {
|
||||
if(!(leaf instanceof ChameleonElement)) return leaf;
|
||||
final ChameleonElement chameleon = (ChameleonElement)leaf;
|
||||
synchronized (PsiLock.LOCK) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("\"transforming chameleon:\" + chameleon + \" in \" + chameleon.parent");
|
||||
|
||||
@@ -162,7 +162,7 @@ public class DeclarationParsing extends Parsing {
|
||||
return first;
|
||||
}
|
||||
|
||||
CompositeElement codeBlock = myContext.getStatementParsing().parseCodeBlock(lexer, false);
|
||||
TreeElement codeBlock = myContext.getStatementParsing().parseCodeBlock(lexer, false);
|
||||
LOG.assertTrue(codeBlock != null);
|
||||
|
||||
CompositeElement initializer = Factory.createCompositeElement(CLASS_INITIALIZER);
|
||||
@@ -810,7 +810,7 @@ public class DeclarationParsing extends Parsing {
|
||||
lexer.advance();
|
||||
}
|
||||
else if (lexer.getTokenType() == LBRACE){
|
||||
CompositeElement codeBlock = myContext.getStatementParsing().parseCodeBlock(lexer, false);
|
||||
TreeElement codeBlock = myContext.getStatementParsing().parseCodeBlock(lexer, false);
|
||||
TreeUtil.addChildren(method, codeBlock);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -96,8 +96,8 @@ public class FileTextParsing extends Parsing {
|
||||
lastPos = lexer.getTokenEnd();
|
||||
lexer.advance();
|
||||
}
|
||||
LeafElement chameleon = Factory.createLeafElement(IMPORT_LIST_TEXT, lexer.getBuffer(), startPos, lastPos, lexer.getState(), myContext.getCharTable());
|
||||
TreeUtil.addChildren(importList, chameleon);
|
||||
LeafElement chameleon = Factory.createLeafElement(IMPORT_LIST, lexer.getBuffer(), startPos, lastPos, lexer.getState(), myContext.getCharTable());
|
||||
return chameleon;
|
||||
}
|
||||
|
||||
return importList;
|
||||
|
||||
@@ -13,6 +13,7 @@ import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.TokenSet;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.util.CharTable;
|
||||
|
||||
public class JavadocParsing extends Parsing {
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.parsing.JavadocParsing");
|
||||
@@ -37,6 +38,33 @@ public class JavadocParsing extends Parsing {
|
||||
super(context);
|
||||
}
|
||||
|
||||
public static TreeElement parseJavaDocReference(char[] myBuffer, CharTable charTable, Lexer originalLexer, int state, boolean isType) {
|
||||
FilterLexer lexer = new FilterLexer(originalLexer, new FilterLexer.SetFilter(ElementType.WHITE_SPACE_OR_COMMENT_BIT_SET));
|
||||
lexer.start(myBuffer, 0, myBuffer.length, state);
|
||||
ParsingContext context = new ParsingContext(charTable);
|
||||
|
||||
final FileElement dummyRoot = new DummyHolder(null, null, context.getCharTable()).getTreeElement();
|
||||
final CompositeElement element;
|
||||
|
||||
if (isType){
|
||||
element = context.getJavadocParsing().parseTypeWithEllipsis(lexer, true, false);
|
||||
}
|
||||
else{
|
||||
element = context.getStatementParsing().parseJavaCodeReference(lexer, true);
|
||||
}
|
||||
|
||||
if (element != null){
|
||||
TreeUtil.addChildren(dummyRoot, element);
|
||||
}
|
||||
while(lexer.getTokenType() != null){
|
||||
TreeUtil.addChildren(dummyRoot, ParseUtil.createTokenElement(lexer, context.getCharTable()));
|
||||
lexer.advance();
|
||||
}
|
||||
|
||||
ParseUtil.insertMissingTokens(dummyRoot, originalLexer, 0, myBuffer.length, state, ParseUtil.WhiteSpaceAndCommentsProcessor.INSTANCE, context);
|
||||
return (TreeElement)dummyRoot.getFirstChildNode();
|
||||
}
|
||||
|
||||
public TreeElement parseDocCommentText(PsiManager manager, char[] buffer, int startOffset, int endOffset) {
|
||||
Lexer originalLexer = new JavaDocLexer(); // we need caching lexer because the lexer has states
|
||||
|
||||
@@ -262,7 +290,7 @@ public class JavadocParsing extends Parsing {
|
||||
}
|
||||
|
||||
private LeafElement parseReferenceOrType(char[] buffer, int startOffset, int endOffset, boolean isType, int lexerState) {
|
||||
return Factory.createLeafElement(isType ? JavaDocTokenType.DOC_TYPE_TEXT : JavaDocTokenType.DOC_REFERENCE_TEXT, buffer, startOffset,
|
||||
return Factory.createLeafElement(isType ? JavaDocElementType.DOC_TYPE_HOLDER : JavaDocElementType.DOC_REFERENCE_HOLDER, buffer, startOffset,
|
||||
endOffset, lexerState, myContext.getCharTable());
|
||||
}
|
||||
|
||||
|
||||
@@ -15,6 +15,7 @@ import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.TokenSet;
|
||||
import com.intellij.psi.tree.IChameleonElementType;
|
||||
import com.intellij.psi.xml.XmlElementType;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.util.CharTable;
|
||||
import com.intellij.lang.ASTNode;
|
||||
|
||||
@@ -34,12 +35,10 @@ public class ParseUtil implements Constants {
|
||||
public static TreeElement createTokenElement(Lexer lexer, CharTable table) {
|
||||
IElementType tokenType = lexer.getTokenType();
|
||||
if (tokenType == null) return null;
|
||||
if (tokenType == DOC_COMMENT) {
|
||||
CompositeElement element = Factory.createCompositeElement(tokenType);
|
||||
LeafElement chameleon = Factory.createLeafElement(DOC_COMMENT_TEXT, lexer.getBuffer(), lexer.getTokenStart(),
|
||||
if (tokenType == JavaTokenType.DOC_COMMENT) {
|
||||
LeafElement chameleon = Factory.createLeafElement(JavaDocElementType.DOC_COMMENT, lexer.getBuffer(), lexer.getTokenStart(),
|
||||
lexer.getTokenEnd(), lexer.getState(), table);
|
||||
TreeUtil.addChildren(element, chameleon);
|
||||
return element;
|
||||
return chameleon;
|
||||
}
|
||||
else {
|
||||
final LeafElement leafElement = Factory.createLeafElement(tokenType, lexer.getBuffer(), lexer.getTokenStart(), lexer.getTokenEnd(),
|
||||
@@ -222,10 +221,12 @@ public class ParseUtil implements Constants {
|
||||
commonParents.strongWhiteSpaceHolder = null;
|
||||
final IElementType tokenType = gt ? GTTokens.getTokenType(lexer) : lexer.getTokenType();
|
||||
final TreeElement next;
|
||||
if(tokenType instanceof IChameleonElementType)
|
||||
if (tokenType instanceof IChameleonElementType) {
|
||||
next = nextLeaf(leaf, commonParents, tokenType);
|
||||
else
|
||||
}
|
||||
else {
|
||||
next = nextLeaf(leaf, commonParents, null);
|
||||
}
|
||||
|
||||
if (next == null || tokenType == null || next == endToken) break;
|
||||
if (tokenType != next.getElementType() && processor.isTokenValid(tokenType)) {
|
||||
@@ -269,7 +270,7 @@ public class ParseUtil implements Constants {
|
||||
}
|
||||
|
||||
private static void passTokenOrChameleon(final ASTNode next, Lexer lexer, boolean gtUse) {
|
||||
if (next instanceof ChameleonElement) {
|
||||
if (next instanceof LeafElement && ((LeafElement)next).isChameleon()) {
|
||||
final int endOfChameleon = next.getTextLength() + lexer.getTokenStart();
|
||||
while (lexer.getTokenType() != null && lexer.getTokenEnd() < endOfChameleon) {
|
||||
lexer.advance();
|
||||
@@ -295,8 +296,9 @@ public class ParseUtil implements Constants {
|
||||
}
|
||||
TreeElement nextTree = start;
|
||||
while (next == null && (nextTree = nextTree.getTreeNext()) != null) {
|
||||
if(nextTree.getElementType() == searchedType)
|
||||
if (nextTree.getElementType() == searchedType) {
|
||||
return nextTree;
|
||||
}
|
||||
next = findFirstLeaf(nextTree, searchedType, commonParent);
|
||||
}
|
||||
if(next != null){
|
||||
@@ -336,8 +338,9 @@ public class ParseUtil implements Constants {
|
||||
public static LeafElement prevLeaf(TreeElement start, CommonParentState commonParent) {
|
||||
LeafElement prev = null;
|
||||
if(commonParent != null){
|
||||
if(commonParent.strongWhiteSpaceHolder != null && start.getUserData(UNCLOSED_ELEMENT_PROPERTY) != null)
|
||||
if (commonParent.strongWhiteSpaceHolder != null && start.getUserData(UNCLOSED_ELEMENT_PROPERTY) != null) {
|
||||
commonParent.strongWhiteSpaceHolder = (CompositeElement)start;
|
||||
}
|
||||
commonParent.startLeafBranchStart = start;
|
||||
}
|
||||
ASTNode prevTree = start;
|
||||
@@ -356,7 +359,7 @@ public class ParseUtil implements Constants {
|
||||
static void bindComments(ASTNode root) {
|
||||
TreeElement child = (TreeElement)root.getFirstChildNode();
|
||||
while (child != null) {
|
||||
if (child.getElementType() == DOC_COMMENT) {
|
||||
if (child.getElementType() == JavaDocElementType.DOC_COMMENT) {
|
||||
if (bindDocComment(child)) {
|
||||
child = child.getTreeParent();
|
||||
continue;
|
||||
|
||||
@@ -2,8 +2,8 @@ package com.intellij.psi.impl.source.parsing;
|
||||
|
||||
import com.intellij.lexer.FilterLexer;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.lexer.JavaWithJspTemplateDataLexer;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.PsiManager;
|
||||
import com.intellij.psi.impl.PsiManagerImpl;
|
||||
@@ -14,7 +14,6 @@ import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.jsp.IJspElementType;
|
||||
import com.intellij.util.CharTable;
|
||||
import com.intellij.lang.ASTNode;
|
||||
|
||||
public class StatementParsing extends Parsing {
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.parsing.StatementParsing");
|
||||
@@ -77,7 +76,7 @@ public class StatementParsing extends Parsing {
|
||||
return (TreeElement)dummyRoot.getFirstChildNode();
|
||||
}
|
||||
|
||||
public CompositeElement parseCodeBlock(Lexer lexer, boolean deep) {
|
||||
public TreeElement parseCodeBlock(Lexer lexer, boolean deep) {
|
||||
if (lexer.getTokenType() != LBRACE) return null;
|
||||
if (lexer instanceof FilterLexer){
|
||||
if (((FilterLexer)lexer).getOriginal() instanceof JspStep1Lexer ||
|
||||
@@ -86,7 +85,6 @@ public class StatementParsing extends Parsing {
|
||||
}
|
||||
}
|
||||
|
||||
CompositeElement codeBlock = Factory.createCompositeElement(CODE_BLOCK);
|
||||
if (!deep){
|
||||
int start = lexer.getTokenStart();
|
||||
lexer.advance();
|
||||
@@ -111,17 +109,17 @@ public class StatementParsing extends Parsing {
|
||||
}
|
||||
lexer.advance();
|
||||
}
|
||||
final TreeElement chameleon = Factory.createLeafElement(CODE_BLOCK, lexer.getBuffer(), start, end, lexer.getState(), myContext.getCharTable());
|
||||
if (braceCount != 0){
|
||||
codeBlock.putUserData(ParseUtil.UNCLOSED_ELEMENT_PROPERTY, "");
|
||||
chameleon.putUserData(ParseUtil.UNCLOSED_ELEMENT_PROPERTY, "");
|
||||
}
|
||||
TreeElement chameleon = Factory.createLeafElement(CODE_BLOCK_TEXT, lexer.getBuffer(), start, end, lexer.getState(), myContext.getCharTable());
|
||||
TreeUtil.addChildren(codeBlock, chameleon);
|
||||
return chameleon;
|
||||
}
|
||||
else{
|
||||
CompositeElement codeBlock = Factory.createCompositeElement(CODE_BLOCK);
|
||||
parseCodeBlockDeep(codeBlock, lexer, false);
|
||||
return codeBlock;
|
||||
}
|
||||
|
||||
return codeBlock;
|
||||
}
|
||||
|
||||
private void parseCodeBlockDeep(CompositeElement elementToAdd,
|
||||
@@ -623,7 +621,7 @@ public class StatementParsing extends Parsing {
|
||||
return element;
|
||||
}
|
||||
|
||||
CompositeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
TreeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
if (codeBlock == null){
|
||||
TreeUtil.addChildren(element, Factory.createErrorElement("'{' expected"));
|
||||
return element;
|
||||
@@ -733,7 +731,7 @@ public class StatementParsing extends Parsing {
|
||||
return element;
|
||||
}
|
||||
|
||||
CompositeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
TreeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
if (codeBlock == null){
|
||||
TreeUtil.addChildren(element, Factory.createErrorElement("'{' expected"));
|
||||
return element;
|
||||
@@ -751,7 +749,7 @@ public class StatementParsing extends Parsing {
|
||||
TreeUtil.addChildren(element, ParseUtil.createTokenElement(lexer, myContext.getCharTable()));
|
||||
lexer.advance();
|
||||
|
||||
CompositeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
TreeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
if (codeBlock == null){
|
||||
TreeUtil.addChildren(element, Factory.createErrorElement("'{' expected"));
|
||||
return element;
|
||||
@@ -785,7 +783,7 @@ public class StatementParsing extends Parsing {
|
||||
}
|
||||
|
||||
private CompositeElement parseCatchSection(Lexer lexer) {
|
||||
CompositeElement codeBlock;
|
||||
TreeElement codeBlock;
|
||||
CompositeElement catchSection = Factory.createCompositeElement(CATCH_SECTION);
|
||||
TreeUtil.addChildren(catchSection, ParseUtil.createTokenElement(lexer, myContext.getCharTable()));
|
||||
lexer.advance();
|
||||
@@ -857,7 +855,7 @@ public class StatementParsing extends Parsing {
|
||||
private CompositeElement parseBlockStatement(Lexer lexer) {
|
||||
LOG.assertTrue(lexer.getTokenType() == LBRACE);
|
||||
CompositeElement element = Factory.createCompositeElement(BLOCK_STATEMENT);
|
||||
CompositeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
TreeElement codeBlock = parseCodeBlock(lexer, DEEP_PARSE_BLOCKS_IN_STATEMENTS);
|
||||
TreeUtil.addChildren(element, codeBlock);
|
||||
return element;
|
||||
}
|
||||
|
||||
@@ -12,7 +12,6 @@ import com.intellij.psi.impl.source.parsing.ParseUtil;
|
||||
import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.TokenSet;
|
||||
import com.intellij.psi.xml.XmlElementType;
|
||||
import com.intellij.psi.xml.XmlTag;
|
||||
import com.intellij.util.CharTable;
|
||||
|
||||
@@ -699,11 +698,9 @@ public class XmlParsing implements ElementType {
|
||||
lexer.start(text, start, end, _OldXmlLexer.DOCTYPE);
|
||||
|
||||
final FileElement dummyRoot = new DummyHolder(null, null, myContext.getCharTable()).getTreeElement();
|
||||
CompositeElement markupDecl = Factory.createCompositeElement(XmlElementType.XML_MARKUP_DECL);
|
||||
TreeUtil.addChildren(dummyRoot, markupDecl);
|
||||
parseMarkupContent(lexer, markupDecl);
|
||||
parseMarkupContent(lexer, dummyRoot);
|
||||
while (lexer.getTokenType() != null) {
|
||||
TreeUtil.addChildren(markupDecl, ParseUtil.createTokenElement(lexer, dummyRoot.getCharTable()));
|
||||
TreeUtil.addChildren(dummyRoot, ParseUtil.createTokenElement(lexer, dummyRoot.getCharTable()));
|
||||
lexer.advance();
|
||||
}
|
||||
originalLexer.start(text, start, end, _OldXmlLexer.DOCTYPE);
|
||||
|
||||
@@ -19,6 +19,8 @@ import com.intellij.psi.impl.source.parsing.tabular.grammar.Grammar;
|
||||
import com.intellij.psi.impl.source.parsing.tabular.grammar.GrammarUtil;
|
||||
import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.psi.text.BlockSupport;
|
||||
import com.intellij.psi.tree.IChameleonElementType;
|
||||
import com.intellij.psi.tree.IErrorCounterChameleonElementType;
|
||||
import com.intellij.util.CharTable;
|
||||
import com.intellij.util.IncorrectOperationException;
|
||||
|
||||
@@ -80,34 +82,40 @@ public class BlockSupportImpl extends BlockSupport implements Constants, Project
|
||||
ASTNode parent = leafAtStart != null && leafAtEnd != null ? TreeUtil.findCommonParent(leafAtStart, leafAtEnd) : treeFileElement;
|
||||
|
||||
int minErrorLevel = Integer.MAX_VALUE;
|
||||
Reparseable bestReparseable = null;
|
||||
Reparseable prevReparseable = null;
|
||||
ASTNode bestReparseable = null;
|
||||
ASTNode prevReparseable = null;
|
||||
boolean theOnlyReparseable = false;
|
||||
|
||||
while(parent != null && !(parent instanceof FileElement)){
|
||||
if(parent instanceof Reparseable){
|
||||
if(parent.getElementType() instanceof IChameleonElementType){
|
||||
final TextRange textRange = parent.getTextRange();
|
||||
final Reparseable reparseable = (Reparseable)parent;
|
||||
boolean lexerChanged = false;
|
||||
final IChameleonElementType reparseable = (IChameleonElementType)parent.getElementType();
|
||||
boolean languageChanged = false;
|
||||
if(prevReparseable != null){
|
||||
lexerChanged = prevReparseable.getLexerClass().equals(reparseable.getLexerClass());
|
||||
languageChanged = prevReparseable.getElementType().getLanguage() != reparseable.getLanguage();
|
||||
}
|
||||
|
||||
int currentErrorLevel = reparseable.getErrorsCount(newFileText, textRange.getStartOffset(), textRange.getEndOffset(), lengthShift);
|
||||
if(currentErrorLevel == Reparseable.NO_ERRORS){
|
||||
final String newTextStr = StringFactory.createStringFromConstantArray(newFileText, textRange.getStartOffset(), textRange.getLength() + lengthShift);
|
||||
if(reparseable.isParsable(newTextStr)){
|
||||
final FileElement treeElement = new DummyHolder(((TreeElement)parent).getManager(), null, treeFileElement.getCharTable()).getTreeElement();
|
||||
final ChameleonElement chameleon = reparseable.createChameleon(newFileText, textRange.getStartOffset(), textRange.getEndOffset() + lengthShift);
|
||||
final ChameleonElement chameleon =
|
||||
(ChameleonElement)Factory.createLeafElement(reparseable, newFileText, textRange.getStartOffset(),
|
||||
textRange.getEndOffset() + lengthShift, -1, treeFileElement.getCharTable());
|
||||
TreeUtil.addChildren(treeElement, chameleon);
|
||||
parent.replaceAllChildrenToChildrenOf(chameleon.transform(treeFileElement.getCharTable(), fileImpl.createLexer()).getTreeParent());
|
||||
return;
|
||||
}
|
||||
else if(currentErrorLevel == Reparseable.FATAL_ERROR){
|
||||
prevReparseable = reparseable;
|
||||
}
|
||||
else if(Math.abs(currentErrorLevel) < Math.abs(minErrorLevel)){
|
||||
theOnlyReparseable = bestReparseable == null;
|
||||
bestReparseable = reparseable;
|
||||
minErrorLevel = currentErrorLevel;
|
||||
if (lexerChanged) break;
|
||||
else if(reparseable instanceof IErrorCounterChameleonElementType){
|
||||
int currentErrorLevel = ((IErrorCounterChameleonElementType)reparseable).getErrorsCount(newTextStr);
|
||||
if(currentErrorLevel == IErrorCounterChameleonElementType.FATAL_ERROR){
|
||||
prevReparseable = parent;
|
||||
}
|
||||
else if(Math.abs(currentErrorLevel) < Math.abs(minErrorLevel)){
|
||||
theOnlyReparseable = bestReparseable == null;
|
||||
bestReparseable = parent;
|
||||
minErrorLevel = currentErrorLevel;
|
||||
if (languageChanged) break;
|
||||
}
|
||||
}
|
||||
// invalid content;
|
||||
}
|
||||
@@ -116,9 +124,11 @@ public class BlockSupportImpl extends BlockSupport implements Constants, Project
|
||||
|
||||
if(bestReparseable != null && !theOnlyReparseable){
|
||||
// best reparseable available
|
||||
final ASTNode treeElement = ((ASTNode)bestReparseable);
|
||||
final ASTNode treeElement = bestReparseable;
|
||||
final TextRange textRange = treeElement.getTextRange();
|
||||
final ChameleonElement chameleon = bestReparseable.createChameleon(newFileText, textRange.getStartOffset(), textRange.getEndOffset() + lengthShift);
|
||||
final ChameleonElement chameleon =
|
||||
(ChameleonElement)Factory.createLeafElement(bestReparseable.getElementType(), newFileText, textRange.getStartOffset(),
|
||||
textRange.getEndOffset() + lengthShift, -1, treeFileElement.getCharTable());
|
||||
chameleon.putUserData(CharTable.CHAR_TABLE_KEY, treeFileElement.getCharTable());
|
||||
chameleon.setTreeParent((CompositeElement)parent);
|
||||
treeElement.replaceAllChildrenToChildrenOf(chameleon.transform(treeFileElement.getCharTable(), fileImpl.createLexer()).getTreeParent());
|
||||
|
||||
@@ -123,9 +123,9 @@ public class CompositeElement extends TreeElement implements Cloneable {
|
||||
while (child != null) {
|
||||
final int textLength = child.getTextLength(table);
|
||||
if (textLength > offset) {
|
||||
if (child instanceof ChameleonElement) {
|
||||
child = ChameleonTransforming.transform((ChameleonElement)child);
|
||||
continue;
|
||||
if (child instanceof LeafElement && ((LeafElement)child).isChameleon()) {
|
||||
child = (TreeElement)ChameleonTransforming.transform((LeafElement)child);
|
||||
continue;
|
||||
}
|
||||
return child.findLeafElementAt(offset);
|
||||
}
|
||||
@@ -178,6 +178,9 @@ public class CompositeElement extends TreeElement implements Cloneable {
|
||||
public final PsiElement findChildByRoleAsPsiElement(int role) {
|
||||
ASTNode element = findChildByRole(role);
|
||||
if (element == null) return null;
|
||||
if (element instanceof LeafElement && ((LeafElement)element).isChameleon()) {
|
||||
element = ChameleonTransforming.transform((LeafElement)element);
|
||||
}
|
||||
return SourceTreeToPsiMap.treeElementToPsi(element);
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,8 @@ package com.intellij.psi.impl.source.tree;
|
||||
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiTypeElement;
|
||||
import com.intellij.psi.TokenType;
|
||||
import com.intellij.psi.TokenTypeEx;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.impl.source.Constants;
|
||||
import com.intellij.psi.impl.source.xml.dtd.DTDElementType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
@@ -10,7 +11,7 @@ import com.intellij.psi.tree.TokenSet;
|
||||
import com.intellij.psi.xml.XmlElementType;
|
||||
|
||||
public interface ElementType extends
|
||||
TokenType,
|
||||
TokenTypeEx,
|
||||
DTDElementType,
|
||||
JavaElementType,
|
||||
JavaDocElementType,
|
||||
@@ -21,11 +22,10 @@ public interface ElementType extends
|
||||
IElementType PLAIN_TEXT = new IElementType("PLAIN_TEXT", null);
|
||||
IElementType CODE_FRAGMENT = new IElementType("CODE_FRAGMENT", null);
|
||||
IElementType DUMMY_HOLDER = new IElementType("DUMMY_HOLDER", null);
|
||||
IElementType GRAMMAR_CHAMELEON = new IElementType("GRAMMAR_CHAMELEON", null);
|
||||
|
||||
TokenSet WHITE_SPACE_BIT_SET = TokenSet.create(new IElementType[]{WHITE_SPACE, JSP_DIRECTIVE_WHITE_SPACE, JSP_ACTION_WHITE_SPACE});
|
||||
|
||||
TokenSet COMMENT_BIT_SET = TokenSet.create(new IElementType[]{END_OF_LINE_COMMENT, C_STYLE_COMMENT, DOC_COMMENT, JSP_COMMENT,
|
||||
TokenSet COMMENT_BIT_SET = TokenSet.create(new IElementType[]{END_OF_LINE_COMMENT, C_STYLE_COMMENT, JavaTokenType.DOC_COMMENT, JSP_COMMENT,
|
||||
XML_COMMENT});
|
||||
|
||||
TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.orSet(WHITE_SPACE_BIT_SET, COMMENT_BIT_SET);
|
||||
|
||||
@@ -2,7 +2,6 @@ package com.intellij.psi.impl.source.tree;
|
||||
|
||||
import com.intellij.aspects.psi.IAspectElementType;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.JavaDocTokenType;
|
||||
import com.intellij.psi.PsiManager;
|
||||
import com.intellij.psi.impl.source.*;
|
||||
import com.intellij.psi.impl.source.html.HtmlDocumentImpl;
|
||||
@@ -14,7 +13,7 @@ import com.intellij.psi.impl.source.jsp.jspJava.JspTemplateStatement;
|
||||
import com.intellij.psi.impl.source.jsp.jspJava.JspText;
|
||||
import com.intellij.psi.impl.source.tree.java.*;
|
||||
import com.intellij.psi.impl.source.xml.*;
|
||||
import com.intellij.psi.jsp.JspTokenType;
|
||||
import com.intellij.psi.tree.IChameleonElementType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.java.IJavaDocElementType;
|
||||
import com.intellij.psi.tree.java.IJavaElementType;
|
||||
@@ -53,52 +52,12 @@ public class Factory implements Constants {
|
||||
|
||||
public static LeafElement createLeafElement(IElementType type, char[] buffer, int startOffset, int endOffset, int lexerState, CharTable table) {
|
||||
LeafElement element = null;
|
||||
if (type == JAVA_FILE_TEXT) {
|
||||
element = new JavaFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
if (type instanceof IChameleonElementType) {
|
||||
element = new ChameleonElement(type, buffer, startOffset, endOffset, lexerState);
|
||||
}
|
||||
else if (type instanceof IXmlLeafElementType) {
|
||||
element = new XmlTokenImpl(type, buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == JSP_FILE_TEXT) {
|
||||
element = new JspFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == XML_FILE_TEXT) {
|
||||
element = new XmlFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
} else if (type == XHTML_FILE_TEXT) {
|
||||
element = new XHtmlFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
} else if (type == JSPX_FILE_TEXT) {
|
||||
element = new JspxFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == HTML_FILE_TEXT) {
|
||||
element = new HTMLFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == DTD_FILE_TEXT) {
|
||||
element = new DTDFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == IMPORT_LIST_TEXT) {
|
||||
element = new ImportListChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == CODE_BLOCK_TEXT) {
|
||||
element = new CodeBlockChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == DOC_COMMENT_TEXT) {
|
||||
element = new DocCommentChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == ASPECT_FILE_TEXT) {
|
||||
element = new AspectFileChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == EXPRESSION_TEXT) {
|
||||
element = new ExpressionChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == STATEMENTS) {
|
||||
element = new StatementsChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == TYPE_TEXT) {
|
||||
element = new TypeChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == REFERENCE_TEXT) {
|
||||
element = new ReferenceChameleonElement(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == PLAIN_TEXT) {
|
||||
element = new PsiPlainTextImpl(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
@@ -111,18 +70,6 @@ public class Factory implements Constants {
|
||||
else if (type == IDENTIFIER) {
|
||||
element = new PsiIdentifierImpl(buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == JavaDocTokenType.DOC_TYPE_TEXT) {
|
||||
element = new JavaDocReferenceChameleon(type, buffer, startOffset, endOffset, true, lexerState, table);
|
||||
}
|
||||
else if (type == JavaDocTokenType.DOC_REFERENCE_TEXT) {
|
||||
element = new JavaDocReferenceChameleon(type, buffer, startOffset, endOffset, false, lexerState, table);
|
||||
}
|
||||
else if (type == JspTokenType.JSP_IMPORT_ATTRIBUTE_CHAMELEON) {
|
||||
element = new JspImportAttributeChameleonElement(type, buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == JspElementType.JSP_DECLARATION_TEXT) {
|
||||
element = new JspDeclarationChameleonElement(type, buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
else if (type == JspElementType.HOLDER_TEMPLATE_DATA) {
|
||||
element = new JspText(null, buffer, startOffset, endOffset, table);
|
||||
}
|
||||
@@ -174,7 +121,8 @@ public class Factory implements Constants {
|
||||
}
|
||||
else if (type == XML_TAG) {
|
||||
element = new XmlTagImpl();
|
||||
} else if (type == HTML_TAG) {
|
||||
}
|
||||
else if (type == HTML_TAG) {
|
||||
element = new HtmlTagImpl();
|
||||
}
|
||||
else if (type == XML_TEXT) {
|
||||
@@ -202,8 +150,18 @@ public class Factory implements Constants {
|
||||
element = new JspFileElement();
|
||||
}
|
||||
else if (type == XML_FILE) {
|
||||
element = new XmlFileElement();
|
||||
} else if (type == HTML_FILE) {
|
||||
element = new XmlFileElement(type);
|
||||
}
|
||||
else if (type == DTD_FILE) {
|
||||
element = new XmlFileElement(type);
|
||||
}
|
||||
else if (type == XHTML_FILE) {
|
||||
element = new XmlFileElement(type);
|
||||
}
|
||||
else if (type == JSPX_FILE) {
|
||||
element = new XmlFileElement(type);
|
||||
}
|
||||
else if (type == HTML_FILE) {
|
||||
element = new HtmlFileElement();
|
||||
}
|
||||
else if (type == CODE_FRAGMENT) {
|
||||
@@ -215,7 +173,7 @@ public class Factory implements Constants {
|
||||
else if (type == ASPECT_FILE) {
|
||||
element = new AspectFileElement();
|
||||
}
|
||||
else if (type == DOC_COMMENT) {
|
||||
else if (type == JavaDocElementType.DOC_COMMENT) {
|
||||
element = new PsiDocCommentImpl();
|
||||
}
|
||||
else if (type == DOC_TAG) {
|
||||
|
||||
@@ -1,15 +1,56 @@
|
||||
package com.intellij.psi.impl.source.tree;
|
||||
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.Language;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.psi.impl.source.ParsingContext;
|
||||
import com.intellij.psi.impl.source.parsing.JavadocParsing;
|
||||
import com.intellij.psi.tree.IChameleonElementType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.java.IJavaDocElementType;
|
||||
import com.intellij.util.text.CharArrayUtil;
|
||||
|
||||
public interface JavaDocElementType {
|
||||
//chameleon
|
||||
IElementType DOC_COMMENT_TEXT = new IJavaDocElementType("DOC_COMMENT_TEXT");
|
||||
|
||||
IElementType DOC_TAG = new IJavaDocElementType("DOC_TAG");
|
||||
IElementType DOC_TAG_VALUE = new IJavaDocElementType("DOC_TAG_VALUE");
|
||||
IElementType DOC_INLINE_TAG = new IJavaDocElementType("DOC_INLINE_TAG");
|
||||
IElementType DOC_METHOD_OR_FIELD_REF = new IJavaDocElementType("DOC_METHOD_OR_FIELD_REF");
|
||||
IElementType DOC_PARAMETER_REF = new IJavaDocElementType("DOC_PARAMETER_REF");
|
||||
|
||||
IElementType DOC_REFERENCE_HOLDER = new IChameleonElementType("DOC_REFERENCE_HOLDER", Language.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return JavadocParsing.parseJavaDocReference(chars, SharedImplUtil.findCharTableByTree(chameleon), getLanguage().getParserDefinition().createLexer(),
|
||||
((LeafElement)chameleon).getState(), false);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
|
||||
IElementType DOC_TYPE_HOLDER = new IChameleonElementType("DOC_TYPE_HOLDER", Language.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return JavadocParsing.parseJavaDocReference(chars, SharedImplUtil.findCharTableByTree(chameleon), getLanguage().getParserDefinition().createLexer(),
|
||||
((LeafElement)chameleon).getState(), true);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
|
||||
IElementType DOC_COMMENT = new IChameleonElementType("DOC_COMMENT", Language.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
final ParsingContext context = new ParsingContext(SharedImplUtil.findCharTableByTree(chameleon));
|
||||
return context.getJavadocParsing().parseDocCommentText(chameleon.getTreeParent().getPsi().getManager(), chars, 0, chars.length);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {
|
||||
final JavaLexer lexer = new JavaLexer(LanguageLevel.JDK_1_5);
|
||||
|
||||
lexer.start(CharArrayUtil.fromSequence(buffer));
|
||||
if(lexer.getTokenType() != DOC_COMMENT) return false;
|
||||
lexer.advance();
|
||||
if(lexer.getTokenType() != null) return false;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,20 +1,23 @@
|
||||
package com.intellij.psi.impl.source.tree;
|
||||
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.java.JavaLanguage;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.impl.source.ParsingContext;
|
||||
import com.intellij.psi.impl.source.parsing.FileTextParsing;
|
||||
import com.intellij.psi.impl.source.parsing.StatementParsing;
|
||||
import com.intellij.psi.impl.source.parsing.Parsing;
|
||||
import com.intellij.psi.tree.IChameleonElementType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.IErrorCounterChameleonElementType;
|
||||
import com.intellij.psi.tree.java.IJavaElementType;
|
||||
import com.intellij.util.text.CharArrayUtil;
|
||||
|
||||
public interface JavaElementType {
|
||||
//chameleons
|
||||
IElementType JAVA_FILE_TEXT = new IJavaElementType("JAVA_FILE_TEXT");
|
||||
IElementType IMPORT_LIST_TEXT = new IJavaElementType("IMPORT_LIST_TEXT");
|
||||
IElementType CODE_BLOCK_TEXT = new IJavaElementType("CODE_BLOCK_TEXT");
|
||||
IElementType EXPRESSION_TEXT = new IJavaElementType("EXPRESSION_TEXT");
|
||||
IElementType JAVA_FILE = new IJavaElementType("JAVA_FILE");
|
||||
IElementType TYPE_PARAMETER = new IJavaElementType("TYPE_PARAMETER");
|
||||
IElementType TYPE_PARAMETER_LIST = new IJavaElementType("TYPE_PARAMETER_LIST");
|
||||
IElementType STATEMENTS = new IJavaElementType("STATEMENTS");
|
||||
IElementType REFERENCE_TEXT = new IJavaElementType("REFERENCE_TEXT");
|
||||
IElementType TYPE_TEXT = new IJavaElementType("TYPE_TEXT");
|
||||
|
||||
IElementType ERROR_ELEMENT = new IJavaElementType("ERROR_ELEMENT");
|
||||
|
||||
@@ -24,14 +27,12 @@ public interface JavaElementType {
|
||||
IElementType CLASS = new IJavaElementType("CLASS");
|
||||
IElementType ANONYMOUS_CLASS = new IJavaElementType("ANONYMOUS_CLASS");
|
||||
IElementType ENUM_CONSTANT_INITIALIZER = new IJavaElementType("ENUM_CONSTANT_INITIALIZER");
|
||||
IElementType IMPORT_LIST = new IJavaElementType("IMPORT_LIST");
|
||||
IElementType IMPORT_STATEMENT = new IJavaElementType("IMPORT_STATEMENT");
|
||||
IElementType IMPORT_STATIC_STATEMENT = new IJavaElementType("IMPORT_STATIC_STATEMENT");
|
||||
IElementType IMPORT_STATIC_REFERENCE = new IJavaElementType("IMPORT_STATIC_REFERENCE");
|
||||
IElementType MODIFIER_LIST = new IJavaElementType("MODIFIER_LIST");
|
||||
IElementType EXTENDS_LIST = new IJavaElementType("EXTENDS_LIST");
|
||||
IElementType IMPLEMENTS_LIST = new IJavaElementType("IMPLEMENTS_LIST");
|
||||
IElementType CODE_BLOCK = new IJavaElementType("CODE_BLOCK");
|
||||
IElementType FIELD = new IJavaElementType("FIELD");
|
||||
IElementType ENUM_CONSTANT = new IJavaElementType("ENUM_CONSTANT");
|
||||
IElementType METHOD = new IJavaElementType("METHOD");
|
||||
@@ -67,7 +68,6 @@ public interface JavaElementType {
|
||||
|
||||
IElementType EMPTY_STATEMENT = new IJavaElementType("EMPTY_STATEMENT");
|
||||
IElementType BLOCK_STATEMENT = new IJavaElementType("BLOCK_STATEMENT");
|
||||
IElementType EXPRESSION_STATEMENT = new IJavaElementType("EXPRESSION_STATEMENT");
|
||||
IElementType EXPRESSION_LIST_STATEMENT = new IJavaElementType("EXPRESSION_LIST_STATEMENT");
|
||||
IElementType DECLARATION_STATEMENT = new IJavaElementType("DECLARATION_STATEMENT");
|
||||
IElementType IF_STATEMENT = new IJavaElementType("IF_STATEMENT");
|
||||
@@ -93,4 +93,85 @@ public interface JavaElementType {
|
||||
IElementType ANNOTATION = new IJavaElementType("ANNOTATION");
|
||||
IElementType NAME_VALUE_PAIR = new IJavaElementType("NAME_VALUE_PAIR");
|
||||
IElementType ANNOTATION_PARAMETER_LIST = new IJavaElementType("ANNOTATION_PARAMETER_LIST");
|
||||
|
||||
IElementType JAVA_FILE = new IChameleonElementType("JAVA_FILE_TEXT", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
|
||||
return FileTextParsing.parseFileText(chameleon.getTreeParent().getPsi().getManager(), getLanguage().getParserDefinition().createLexer(),
|
||||
chars, 0, chars.length, SharedImplUtil.findCharTableByTree(chameleon));
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return true;}
|
||||
};
|
||||
|
||||
IElementType IMPORT_LIST = new IChameleonElementType("IMPORT_LIST_TEXT", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
final ParsingContext context = new ParsingContext(SharedImplUtil.findCharTableByTree(chameleon));
|
||||
return context.getImportsTextParsing().parseImportsText(chameleon.getTreeParent().getPsi().getManager(), getLanguage().getParserDefinition().createLexer(),
|
||||
chars, 0, chars.length, ((LeafElement)chameleon).getState());
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
|
||||
IElementType CODE_BLOCK = new IErrorCounterChameleonElementType("CODE_BLOCK_TEXT", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return StatementParsing.parseCodeBlockText(chameleon.getTreeParent().getPsi().getManager(), getLanguage().getParserDefinition().createLexer(),
|
||||
chars, 0, chars.length, ((LeafElement)chameleon).getState(),
|
||||
SharedImplUtil.findCharTableByTree(chameleon)).getFirstChildNode();
|
||||
}
|
||||
public int getErrorsCount(CharSequence seq) {
|
||||
final Lexer lexer = getLanguage().getParserDefinition().createLexer();
|
||||
final char[] chars = CharArrayUtil.fromSequence(seq);
|
||||
lexer.start(chars, 0, chars.length);
|
||||
int balance = 0;
|
||||
while(true){
|
||||
IElementType type = lexer.getTokenType();
|
||||
if (type == null) break;
|
||||
if (type == JavaTokenType.LBRACE) {
|
||||
balance++;
|
||||
}
|
||||
else if (type == JavaTokenType.RBRACE) {
|
||||
balance--;
|
||||
}
|
||||
lexer.advance();
|
||||
}
|
||||
return balance;
|
||||
}
|
||||
};
|
||||
|
||||
IElementType EXPRESSION_STATEMENT = new IChameleonElementType("EXPRESSION_TEXT", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
final ParsingContext context = new ParsingContext(SharedImplUtil.findCharTableByTree(chameleon));
|
||||
return context.getExpressionParsing().parseExpressionTextFragment(chameleon.getTreeParent().getPsi().getManager(), chars, 0, chars.length, ((LeafElement)chameleon).getState());
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
|
||||
IElementType REFERENCE_TEXT = new IChameleonElementType("REFERENCE_TEXT", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return Parsing.parseJavaCodeReferenceText(chameleon.getTreeParent().getPsi().getManager(), chars, 0, chars.length, SharedImplUtil.findCharTableByTree(chameleon), true);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
|
||||
IElementType TYPE_TEXT = new IChameleonElementType("TYPE_TEXT", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return Parsing.parseTypeText(chameleon.getTreeParent().getPsi().getManager(), chars, 0, chars.length, SharedImplUtil.findCharTableByTree(chameleon));
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
|
||||
IElementType STATEMENTS = new IChameleonElementType("STATEMENTS", JavaLanguage.findByID("JAVA")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return StatementParsing.parseStatements(chameleon.getTreeParent().getPsi().getManager(), getLanguage().getParserDefinition().createLexer(), chars, 0, chars.length,
|
||||
((LeafElement)chameleon).getState(), SharedImplUtil.findCharTableByTree(chameleon));
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return false;}
|
||||
};
|
||||
}
|
||||
|
||||
@@ -171,4 +171,8 @@ public abstract class LeafElement extends TreeElement {
|
||||
public PsiElement getPsi() {
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean isChameleon(){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,12 +4,12 @@ import com.intellij.lang.Language;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiElementVisitor;
|
||||
import com.intellij.psi.PsiWhiteSpace;
|
||||
import com.intellij.psi.TokenType;
|
||||
import com.intellij.psi.TokenTypeEx;
|
||||
import com.intellij.util.CharTable;
|
||||
|
||||
public class PsiWhiteSpaceImpl extends LeafPsiElement implements PsiWhiteSpace {
|
||||
public PsiWhiteSpaceImpl(char[] buffer, int startOffset, int endOffset, int lexerState, CharTable table) {
|
||||
super(TokenType.WHITE_SPACE, buffer, startOffset, endOffset, lexerState, table);
|
||||
super(TokenTypeEx.WHITE_SPACE, buffer, startOffset, endOffset, lexerState, table);
|
||||
}
|
||||
|
||||
public void accept(PsiElementVisitor visitor){
|
||||
|
||||
@@ -2,6 +2,7 @@ package com.intellij.psi.impl.source.tree;
|
||||
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
|
||||
public class XmlFileElement extends FileElement{
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.XmlFileElement");
|
||||
@@ -10,6 +11,10 @@ public class XmlFileElement extends FileElement{
|
||||
super(XML_FILE);
|
||||
}
|
||||
|
||||
public XmlFileElement(IElementType type) {
|
||||
super(type);
|
||||
}
|
||||
|
||||
public int getChildRole(ASTNode child) {
|
||||
LOG.assertTrue(child.getTreeParent() == this);
|
||||
if (child.getElementType() == XML_DOCUMENT) {
|
||||
|
||||
@@ -146,7 +146,7 @@ public class ClassElement extends RepositoryTreeElement {
|
||||
return null;
|
||||
|
||||
case ChildRole.DOC_COMMENT:
|
||||
if (getFirstChildNode().getElementType() == DOC_COMMENT) {
|
||||
if (getFirstChildNode().getElementType() == JavaDocElementType.DOC_COMMENT) {
|
||||
return getFirstChildNode();
|
||||
}
|
||||
else {
|
||||
@@ -240,7 +240,7 @@ public class ClassElement extends RepositoryTreeElement {
|
||||
else if (i == TYPE_PARAMETER_LIST) {
|
||||
return ChildRole.TYPE_PARAMETER_LIST;
|
||||
}
|
||||
else if (i == DOC_COMMENT) {
|
||||
else if (i == JavaDocElementType.DOC_COMMENT) {
|
||||
return getChildRole(child, ChildRole.DOC_COMMENT);
|
||||
}
|
||||
else if (i == C_STYLE_COMMENT || i == END_OF_LINE_COMMENT) {
|
||||
|
||||
@@ -29,6 +29,9 @@ public class EnumConstantElement extends RepositoryTreeElement {
|
||||
if (getFirstChildNode().getElementType() == JavaTokenType.DOC_COMMENT){
|
||||
return getFirstChildNode();
|
||||
}
|
||||
else if(getFirstChildNode().getElementType() == JavaDocElementType.DOC_COMMENT){
|
||||
return getFirstChildNode();
|
||||
}
|
||||
else{
|
||||
return null;
|
||||
}
|
||||
@@ -50,7 +53,7 @@ public class EnumConstantElement extends RepositoryTreeElement {
|
||||
public int getChildRole(ASTNode child) {
|
||||
LOG.assertTrue(child.getTreeParent() == this);
|
||||
IElementType i = child.getElementType();
|
||||
if (i == JavaTokenType.DOC_COMMENT) {
|
||||
if (i == JavaTokenType.DOC_COMMENT || i == JavaDocElementType.DOC_COMMENT) {
|
||||
return getChildRole(child, ChildRole.DOC_COMMENT);
|
||||
}
|
||||
else if (i == JavaTokenType.C_STYLE_COMMENT || i == JavaTokenType.END_OF_LINE_COMMENT) {
|
||||
|
||||
@@ -37,6 +37,9 @@ public class FieldElement extends RepositoryTreeElement{
|
||||
if (getFirstChildNode().getElementType() == JavaTokenType.DOC_COMMENT){
|
||||
return getFirstChildNode();
|
||||
}
|
||||
else if (getFirstChildNode().getElementType() == JavaDocElementType.DOC_COMMENT){
|
||||
return getFirstChildNode();
|
||||
}
|
||||
else{
|
||||
return null;
|
||||
}
|
||||
@@ -64,7 +67,7 @@ public class FieldElement extends RepositoryTreeElement{
|
||||
public int getChildRole(ASTNode child) {
|
||||
LOG.assertTrue(child.getTreeParent() == this);
|
||||
IElementType i = child.getElementType();
|
||||
if (i == JavaTokenType.DOC_COMMENT) {
|
||||
if (i == JavaTokenType.DOC_COMMENT || i == JavaDocElementType.DOC_COMMENT) {
|
||||
return getChildRole(child, ChildRole.DOC_COMMENT);
|
||||
}
|
||||
else if (i == JavaTokenType.C_STYLE_COMMENT || i == JavaTokenType.END_OF_LINE_COMMENT) {
|
||||
|
||||
@@ -4,6 +4,7 @@ import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.util.CharTable;
|
||||
import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.lang.ASTNode;
|
||||
|
||||
public class MethodElement extends RepositoryTreeElement{
|
||||
@@ -47,7 +48,8 @@ public class MethodElement extends RepositoryTreeElement{
|
||||
return null;
|
||||
|
||||
case ChildRole.DOC_COMMENT:
|
||||
if (getFirstChildNode().getElementType() == DOC_COMMENT){
|
||||
if (getFirstChildNode().getElementType() == JavaDocElementType.DOC_COMMENT
|
||||
|| getFirstChildNode().getElementType() == JavaTokenType.DOC_COMMENT){
|
||||
return getFirstChildNode();
|
||||
}
|
||||
else{
|
||||
@@ -83,7 +85,7 @@ public class MethodElement extends RepositoryTreeElement{
|
||||
public int getChildRole(ASTNode child) {
|
||||
LOG.assertTrue(child.getTreeParent() == this);
|
||||
IElementType i = child.getElementType();
|
||||
if (i == DOC_COMMENT) {
|
||||
if (i == JavaTokenType.DOC_COMMENT || i == JavaDocElementType.DOC_COMMENT) {
|
||||
return getChildRole(child, ChildRole.DOC_COMMENT);
|
||||
}
|
||||
else if (i == C_STYLE_COMMENT || i == END_OF_LINE_COMMENT) {
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
package com.intellij.psi.impl.source.tree.java;
|
||||
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.openapi.util.TextRange;
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.impl.source.parsing.ChameleonTransforming;
|
||||
import com.intellij.psi.impl.source.tree.*;
|
||||
import com.intellij.psi.scope.BaseScopeProcessor;
|
||||
@@ -11,14 +11,12 @@ import com.intellij.psi.scope.ElementClassHint;
|
||||
import com.intellij.psi.scope.NameHint;
|
||||
import com.intellij.psi.scope.PsiScopeProcessor;
|
||||
import com.intellij.psi.scope.util.PsiScopesUtil;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
public class PsiCodeBlockImpl extends CompositePsiElement implements PsiCodeBlock, Reparseable {
|
||||
public class PsiCodeBlockImpl extends CompositePsiElement implements PsiCodeBlock{
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiCodeBlockImpl");
|
||||
|
||||
public PsiCodeBlockImpl() {
|
||||
@@ -169,29 +167,6 @@ public class PsiCodeBlockImpl extends CompositePsiElement implements PsiCodeBloc
|
||||
return true;
|
||||
}
|
||||
|
||||
public ChameleonElement createChameleon(char[] buffer, int start, int end) {
|
||||
LeafElement firstLeaf = TreeUtil.findFirstLeaf(this);
|
||||
return new CodeBlockChameleonElement(buffer, start, end, firstLeaf != null ? firstLeaf.getState() : -1, SharedImplUtil.findCharTableByTree(this));
|
||||
}
|
||||
|
||||
public int getErrorsCount(char[] buffer, int start, int end, int lengthShift) {
|
||||
final JavaLexer lexer = new JavaLexer(getManager().getEffectiveLanguageLevel());
|
||||
lexer.start(buffer, start, end + lengthShift);
|
||||
int balance = 0;
|
||||
while(true){
|
||||
IElementType type = lexer.getTokenType();
|
||||
if (type == null) break;
|
||||
if (type == LBRACE) {
|
||||
balance++;
|
||||
}
|
||||
else if (type == RBRACE) {
|
||||
balance--;
|
||||
}
|
||||
lexer.advance();
|
||||
}
|
||||
return balance;
|
||||
}
|
||||
|
||||
public Class getLexerClass() {
|
||||
return JavaLexer.class;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.intellij.psi.impl.source.tree.java;
|
||||
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.psi.PsiElement;
|
||||
import com.intellij.psi.PsiElementVisitor;
|
||||
@@ -8,13 +9,12 @@ import com.intellij.psi.impl.SharedPsiElementImplUtil;
|
||||
import com.intellij.psi.impl.source.SourceTreeToPsiMap;
|
||||
import com.intellij.psi.impl.source.tree.ChildRole;
|
||||
import com.intellij.psi.impl.source.tree.CompositePsiElement;
|
||||
import com.intellij.psi.impl.source.tree.TreeElement;
|
||||
import com.intellij.psi.impl.source.tree.JavaDocElementType;
|
||||
import com.intellij.psi.javadoc.PsiDocComment;
|
||||
import com.intellij.psi.javadoc.PsiDocTagValue;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.TokenSet;
|
||||
import com.intellij.util.IncorrectOperationException;
|
||||
import com.intellij.lang.ASTNode;
|
||||
|
||||
public class PsiInlineDocTagImpl extends CompositePsiElement implements PsiInlineDocTag {
|
||||
private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiInlineDocTagImpl");
|
||||
@@ -33,7 +33,7 @@ public class PsiInlineDocTagImpl extends CompositePsiElement implements PsiInlin
|
||||
|
||||
public PsiDocComment getContainingComment() {
|
||||
ASTNode scope = getTreeParent();
|
||||
while (scope.getElementType() != DOC_COMMENT) {
|
||||
while (scope.getElementType() != JavaDocElementType.DOC_COMMENT) {
|
||||
scope = scope.getTreeParent();
|
||||
}
|
||||
return (PsiDocComment)SourceTreeToPsiMap.treeElementToPsi(scope);
|
||||
@@ -63,7 +63,7 @@ public class PsiInlineDocTagImpl extends CompositePsiElement implements PsiInlin
|
||||
if (i == DOC_TAG_NAME) {
|
||||
return ChildRole.DOC_TAG_NAME;
|
||||
}
|
||||
else if (i == DOC_COMMENT_TEXT || i == DOC_INLINE_TAG) {
|
||||
else if (i == JavaDocElementType.DOC_COMMENT || i == DOC_INLINE_TAG) {
|
||||
return ChildRole.DOC_CONTENT;
|
||||
}
|
||||
else if (i == DOC_INLINE_TAG_START) {
|
||||
|
||||
@@ -205,7 +205,7 @@ public class XmlEntityDeclImpl extends XmlElementImpl implements XmlEntityDecl {
|
||||
for (ASTNode e = getFirstChildNode(); e != null; e = e.getTreeNext()) {
|
||||
if (e.getElementType() instanceof IXmlLeafElementType) {
|
||||
XmlToken token = (XmlToken)SourceTreeToPsiMap.treeElementToPsi(e);
|
||||
if (token.getTokenType() == XmlTokenType.XML_DOCTYPE_PUBLIC || token.getTokenType() == XmlToken.XML_DOCTYPE_SYSTEM) {
|
||||
if (token.getTokenType() == XmlTokenType.XML_DOCTYPE_PUBLIC || token.getTokenType() == XmlTokenType.XML_DOCTYPE_SYSTEM) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ import com.intellij.psi.xml.XmlFile;
|
||||
*/
|
||||
public class XmlFileImpl extends PsiFileImpl implements XmlFile {
|
||||
public XmlFileImpl(Project project, VirtualFile file) {
|
||||
super(project, XML_FILE, getChameleonTypeByFile(file), file);
|
||||
super(project, getElementType(file.getFileType()), getChameleonTypeByFile(file), file);
|
||||
}
|
||||
|
||||
public XmlFileImpl(Project project, VirtualFile file, IElementType elementType, IElementType contentElementType) {
|
||||
@@ -36,15 +36,15 @@ public class XmlFileImpl extends PsiFileImpl implements XmlFile {
|
||||
}
|
||||
|
||||
private static IElementType getElementType(final FileType fileTypeByFile) {
|
||||
if (fileTypeByFile == StdFileTypes.XML) return XML_FILE_TEXT;
|
||||
if (fileTypeByFile == StdFileTypes.XHTML) return XHTML_FILE_TEXT;
|
||||
if (fileTypeByFile == StdFileTypes.HTML) return HTML_FILE_TEXT;
|
||||
if (fileTypeByFile == StdFileTypes.DTD) return DTD_FILE_TEXT;
|
||||
if (fileTypeByFile == StdFileTypes.XML) return XML_FILE;
|
||||
if (fileTypeByFile == StdFileTypes.XHTML) return XHTML_FILE;
|
||||
if (fileTypeByFile == StdFileTypes.HTML) return HTML_FILE;
|
||||
if (fileTypeByFile == StdFileTypes.DTD) return DTD_FILE;
|
||||
return null;
|
||||
}
|
||||
|
||||
public XmlFileImpl(Project project, String name, CharSequence text, FileType fileType) {
|
||||
super(project, XML_FILE, getElementType(fileType), name, text);
|
||||
super(project, getElementType(fileType), getElementType(fileType), name, text);
|
||||
}
|
||||
|
||||
public XmlFileImpl(Project project, String name, CharSequence text, FileType fileType, IElementType elementType) {
|
||||
|
||||
@@ -10,7 +10,6 @@ import com.intellij.psi.tree.xml.IDTDElementType;
|
||||
* To change this template use File | Settings | File Templates.
|
||||
*/
|
||||
public interface DTDElementType {
|
||||
IDTDElementType DTD_FILE = new IDTDElementType("DTD_FILE");
|
||||
IDTDElementType DTD_DOCUMENT = new IDTDElementType("DTD_DOCUMENT");
|
||||
IDTDElementType DTD_ELEMENT_DECL = new IDTDElementType("DTD_ELEMENT_DECL");
|
||||
IDTDElementType DTD_ATTLIST_DECL = new IDTDElementType("DTD_ATTLIST_DECL");
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package com.intellij.psi.tree;
|
||||
|
||||
import com.intellij.lang.Language;
|
||||
|
||||
public abstract class IErrorCounterChameleonElementType extends IChameleonElementType{
|
||||
public static final int NO_ERRORS = 0;
|
||||
public static final int FATAL_ERROR = Integer.MIN_VALUE;
|
||||
|
||||
public IErrorCounterChameleonElementType(final String debugName, final Language language) {
|
||||
super(debugName, language);
|
||||
}
|
||||
|
||||
public abstract int getErrorsCount(CharSequence seq);
|
||||
|
||||
public boolean isParsable(CharSequence buffer) {
|
||||
return getErrorsCount(buffer) == NO_ERRORS;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
package com.intellij.psi.xml;
|
||||
|
||||
import com.intellij.psi.JavaTokenType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.xml.IDTDElementType;
|
||||
|
||||
/**
|
||||
* Created by IntelliJ IDEA.
|
||||
* User: ik
|
||||
* Date: 18.08.2004
|
||||
* Time: 16:45:52
|
||||
* To change this template use File | Settings | File Templates.
|
||||
*/
|
||||
public interface DTDTokenType {
|
||||
IDTDElementType DTD_NAME = new IDTDElementType("DTD_NAME");
|
||||
IDTDElementType DTD_NMTOKEN = new IDTDElementType("DTD_NMTOKEN");
|
||||
IDTDElementType DTD_ATTRIBUTE_VALUE_TOKEN = new IDTDElementType("DTD_ATTRIBUTE_VALUE_TOKEN");
|
||||
IDTDElementType DTD_ATTRIBUTE_VALUE_START_DELIMITER = new IDTDElementType("DTD_ATTRIBUTE_VALUE_START_DELIMITER");// "\"" or "'"
|
||||
IDTDElementType DTD_ATTRIBUTE_VALUE_END_DELIMITER = new IDTDElementType("DTD_ATTRIBUTE_VALUE_END_DELIMITER");// "\"" or "'"
|
||||
|
||||
IDTDElementType DTD_ELEMENT_DECL_START = new IDTDElementType("DTD_ELEMENT_DECL_START");//<!ELEMENT
|
||||
IDTDElementType DTD_NOTATION_DECL_START = new IDTDElementType("DTD_NOTATION_DECL_START");//<!NOTATION
|
||||
IDTDElementType DTD_ATTLIST_DECL_START = new IDTDElementType("DTD_ATTLIST_DECL_START");//<!ATTLIST
|
||||
IDTDElementType DTD_ENTITY_DECL_START = new IDTDElementType("DTD_ENTITY_DECL_START");//<!ENTITY
|
||||
IDTDElementType DTD_CONDITIONAL_START = new IDTDElementType("DTD_CONDITIONAL_START");
|
||||
|
||||
IDTDElementType DTD_DECL_END = new IDTDElementType("DTD_DECL_END");
|
||||
|
||||
IDTDElementType DTD_LEFT_PAREN = new IDTDElementType("DTD_LEFT_PAREN");//(
|
||||
IDTDElementType DTD_RIGHT_PAREN = new IDTDElementType("DTD_RIGHT_PAREN");//)
|
||||
IDTDElementType DTD_QUESTION = new IDTDElementType("DTD_QUESTION");//?
|
||||
IDTDElementType DTD_STAR = new IDTDElementType("DTD_STAR");//*
|
||||
IDTDElementType DTD_PLUS = new IDTDElementType("DTD_PLUS");//+
|
||||
IDTDElementType DTD_BAR = new IDTDElementType("DTD_BAR");//|
|
||||
IDTDElementType DTD_COMMA = new IDTDElementType("DTD_COMMA");//,
|
||||
IDTDElementType DTD_AMP = new IDTDElementType("DTD_AMP");//&
|
||||
IDTDElementType DTD_PERCENT = new IDTDElementType("DTD_PERCENT");//%
|
||||
|
||||
IDTDElementType DTD_TAG_CONTENT_SPEC = new IDTDElementType("DTD_TAG_CONTENT_SPEC");// EMPTY, ANY...
|
||||
IDTDElementType DTD_PCDATA = new IDTDElementType("DTD_PCDATA");//#PCDATA
|
||||
|
||||
IDTDElementType DTD_ATTR_CONTENT_SPEC = new IDTDElementType("DTD_ATTR_CONTENT_SPEC");
|
||||
|
||||
IDTDElementType DTD_ATT_IMPLIED = new IDTDElementType("DTD_ATT_IMPLIED");//; #IMPLIED
|
||||
IDTDElementType DTD_ATT_REQUIRED = new IDTDElementType("DTD_ATT_REQUIRED");//; #REQUIRED
|
||||
IDTDElementType DTD_ATT_FIXED = new IDTDElementType("DTD_ATT_FIXED");//; #FIXED
|
||||
|
||||
IDTDElementType DTD_ENTITY_REF_TOKEN = new IDTDElementType("DTD_ENTITY_REF_TOKEN");
|
||||
IDTDElementType DTD_CHAR_ENTITY_REF = new IDTDElementType("DTD_CHAR_ENTITY_REF");
|
||||
|
||||
IDTDElementType DTD_INCLUDE = new IDTDElementType("DTD_INCLUDE");
|
||||
IDTDElementType DTD_IGNORE = new IDTDElementType("DTD_IGNORE");
|
||||
|
||||
IDTDElementType DTD_PUBLIC = new IDTDElementType("DTD_PUBLIC");
|
||||
IDTDElementType DTD_SYSTEM = new IDTDElementType("DTD_SYSTEM");
|
||||
|
||||
IDTDElementType DTD_NOTATION = new IDTDElementType("DTD_NOTATION");
|
||||
|
||||
IDTDElementType DTD_NDATA = new IDTDElementType("DTD_NDATA");
|
||||
|
||||
IDTDElementType DTD_BAD_CHARACTER = new IDTDElementType("DTD_BAD_CHARACTER");
|
||||
|
||||
IElementType DTD_WHITE_SPACE = JavaTokenType.WHITE_SPACE;
|
||||
|
||||
IElementType DTD_COMMENT_START = XmlTokenType.XML_COMMENT_START;
|
||||
IElementType DTD_COMMENT_END = XmlTokenType.XML_COMMENT_END;
|
||||
IElementType DTD_COMMENT_CHARACTERS = XmlTokenType.XML_COMMENT_CHARACTERS;
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
package com.intellij.psi.xml;
|
||||
|
||||
import com.intellij.psi.tree.IChameleonElementType;
|
||||
import com.intellij.psi.tree.IElementType;
|
||||
import com.intellij.psi.tree.xml.IXmlElementType;
|
||||
import com.intellij.psi.impl.source.tree.LeafElement;
|
||||
import com.intellij.psi.impl.source.tree.SharedImplUtil;
|
||||
import com.intellij.psi.impl.source.parsing.xml.DTDMarkupParser;
|
||||
import com.intellij.psi.impl.source.parsing.xml.DTDParser;
|
||||
import com.intellij.psi.impl.source.parsing.tabular.ParsingException;
|
||||
import com.intellij.psi.impl.source.parsing.tabular.ParsingUtil;
|
||||
import com.intellij.psi.impl.source.parsing.tabular.grammar.Grammar;
|
||||
import com.intellij.psi.impl.source.parsing.tabular.grammar.GrammarUtil;
|
||||
import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.Language;
|
||||
import com.intellij.lexer.OldXmlLexer;
|
||||
import com.intellij.util.text.CharArrayUtil;
|
||||
import com.intellij.openapi.fileTypes.StdFileTypes;
|
||||
|
||||
|
||||
public interface XmlElementType {
|
||||
IElementType XML_DOCUMENT = new IXmlElementType("XML_DOCUMENT");
|
||||
IElementType XML_PROLOG = new IXmlElementType("XML_PROLOG");
|
||||
IElementType XML_DECL = new IXmlElementType("XML_DECL");
|
||||
IElementType XML_DOCTYPE = new IXmlElementType("XML_DOCTYPE");
|
||||
IElementType XML_ATTRIBUTE = new IXmlElementType("XML_ATTRIBUTE");
|
||||
IElementType XML_COMMENT = new IXmlElementType("XML_COMMENT");
|
||||
IElementType XML_TAG = new IXmlElementType("XML_TAG");
|
||||
IElementType XML_ELEMENT_DECL = new IXmlElementType("XML_ELEMENT_DECL");
|
||||
IElementType XML_ATTLIST_DECL = new IXmlElementType("XML_ATTLIST_DECL");
|
||||
IElementType XML_NOTATION_DECL = new IXmlElementType("XML_NOTATION_DECL");
|
||||
IElementType XML_ENTITY_DECL = new IXmlElementType("XML_ENTITY_DECL");
|
||||
IElementType XML_ELEMENT_CONTENT_SPEC = new IXmlElementType("XML_ELEMENT_CONTENT_SPEC");
|
||||
IElementType XML_ATTRIBUTE_DECL = new IXmlElementType("XML_ATTRIBUTE_DECL");
|
||||
IElementType XML_ATTRIBUTE_VALUE = new IXmlElementType("XML_ATTRIBUTE_VALUE");
|
||||
IElementType XML_ENTITY_REF = new IXmlElementType("XML_ENTITY_REF");
|
||||
IElementType XML_ENUMERATED_TYPE = new IXmlElementType("XML_ENUMERATED_TYPE");
|
||||
IElementType XML_PROCESSING_INSTRUCTION = new IXmlElementType("XML_PROCESSING_INSTRUCTION");
|
||||
IElementType XML_CDATA = new IXmlElementType("XML_CDATA");
|
||||
IElementType XML_DTD_DECL = new IXmlElementType("XML_DTD_DECL");
|
||||
IElementType XML_WHITE_SPACE_HOLDER = new IXmlElementType("XML_WHITE_SPACE_HOLDER");
|
||||
IElementType HTML_DOCUMENT = new IXmlElementType("HTML_DOCUMENT");
|
||||
IElementType HTML_TAG = new IXmlElementType("HTML_TAG");
|
||||
IElementType XML_TEXT = new IXmlElementType("XML_TEXT");
|
||||
|
||||
|
||||
IElementType HTML_FILE = new IChameleonElementType("HTML_FILE", Language.findByID("HTML")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final Grammar grammarByName = GrammarUtil.getGrammarByName(StdFileTypes.HTML.getName());
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return ParsingUtil.parse(grammarByName, SharedImplUtil.findCharTableByTree(chameleon), chars);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return true;}
|
||||
};
|
||||
|
||||
IElementType XML_FILE = new IChameleonElementType("XML_FILE", Language.findByID("XML")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final Grammar grammarByName = GrammarUtil.getGrammarByName(StdFileTypes.XML.getName());
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return ParsingUtil.parse(grammarByName, SharedImplUtil.findCharTableByTree(chameleon), chars);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return true;}
|
||||
};
|
||||
|
||||
|
||||
IElementType XHTML_FILE = new IChameleonElementType("XML_FILE", Language.findByID("XML")){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final Grammar grammarByName = GrammarUtil.getGrammarByName(StdFileTypes.XHTML.getName());
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
return ParsingUtil.parse(grammarByName, SharedImplUtil.findCharTableByTree(chameleon), chars);
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return true;}
|
||||
};
|
||||
|
||||
|
||||
IElementType DTD_FILE = new IChameleonElementType("DTD_FILE"){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
final DTDParser parser = new DTDParser();
|
||||
try {
|
||||
return parser.parse(chars, 0, chars.length, SharedImplUtil.findCharTableByTree(chameleon));
|
||||
}
|
||||
catch (ParsingException e) {}
|
||||
return null;
|
||||
}
|
||||
public boolean isParsable(CharSequence buffer) {return true;}
|
||||
};
|
||||
|
||||
IElementType XML_MARKUP = new IChameleonElementType("XML_MARKUP_DECL"){
|
||||
public ASTNode parseContents(ASTNode chameleon) {
|
||||
final char[] chars = ((LeafElement)chameleon).textToCharArray();
|
||||
final DTDMarkupParser parser = new DTDMarkupParser();
|
||||
try {
|
||||
return parser.parse(chars, 0, chars.length, SharedImplUtil.findCharTableByTree(chameleon));
|
||||
}
|
||||
catch (ParsingException e) {}
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean isParsable(CharSequence buffer) {
|
||||
final OldXmlLexer oldXmlLexer = new OldXmlLexer();
|
||||
final char[] chars = CharArrayUtil.fromSequence(buffer);
|
||||
|
||||
oldXmlLexer.start(chars, 0, chars.length);
|
||||
while(oldXmlLexer.getTokenType() != null && oldXmlLexer.getTokenEnd() != buffer.length()){
|
||||
if(oldXmlLexer.getTokenType() == XmlTokenType.XML_MARKUP_END) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
+2
-2
@@ -74,6 +74,6 @@ public interface XmlTokenType {
|
||||
IElementType XML_CHAR_ENTITY_REF = new IXmlLeafElementType("XML_CHAR_ENTITY_REF");
|
||||
|
||||
IElementType XML_BAD_CHARACTER = new IXmlLeafElementType("XML_BAD_CHARACTER");
|
||||
IElementType XML_MARKUP = XmlElementType.XML_MARKUP_DECL; //chameleon
|
||||
IElementType XML_EMBEDDED_CHAMELEON = XmlElementType.XML_EMBEDDED_CHAMELEON; //chameleon
|
||||
IElementType XML_EMBEDDED_CHAMELEON = new IXmlLeafElementType("XML_EMBEDDED_CONTENT");
|
||||
IElementType XML_MARKUP_DECL = XmlElementType.XML_MARKUP;
|
||||
}
|
||||
@@ -19,10 +19,7 @@ import com.intellij.openapi.editor.ScrollType;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.psi.*;
|
||||
import com.intellij.psi.codeStyle.CodeStyleManager;
|
||||
import com.intellij.psi.jsp.JspAction;
|
||||
import com.intellij.psi.jsp.JspExpression;
|
||||
import com.intellij.psi.jsp.JspFile;
|
||||
import com.intellij.psi.jsp.JspToken;
|
||||
import com.intellij.psi.jsp.*;
|
||||
import com.intellij.psi.util.PsiTreeUtil;
|
||||
import com.intellij.psi.util.PsiUtil;
|
||||
import com.intellij.refactoring.IntroduceHandlerBase;
|
||||
@@ -350,11 +347,11 @@ public abstract class IntroduceVariableBase extends IntroduceHandlerBase impleme
|
||||
PsiElement prev = child.getPrevSibling();
|
||||
if (prev instanceof PsiStatement) break;
|
||||
if (prev instanceof PsiJavaToken && ((PsiJavaToken)prev).getTokenType() == JavaTokenType.LBRACE) break;
|
||||
if (prev instanceof JspToken && ((JspToken) prev).getTokenType() == JspToken.JSP_SCRIPTLET_START) break;
|
||||
if (prev instanceof JspToken && ((JspToken) prev).getTokenType() == JspTokenType.JSP_SCRIPTLET_START) break;
|
||||
child = prev;
|
||||
if (child instanceof JspToken && ((JspToken) child).getTokenType() == JspToken.JSP_SCRIPTLET_END) break;
|
||||
if (child instanceof JspToken && ((JspToken) child).getTokenType() == JspTokenType.JSP_SCRIPTLET_END) break;
|
||||
}
|
||||
if (!(child instanceof JspToken && ((JspToken) child).getTokenType() == JspToken.JSP_SCRIPTLET_END)) {
|
||||
if (!(child instanceof JspToken && ((JspToken) child).getTokenType() == JspTokenType.JSP_SCRIPTLET_END)) {
|
||||
while (true) {
|
||||
if (!(child instanceof PsiWhiteSpace)
|
||||
&& !(child instanceof PsiComment)
|
||||
|
||||
@@ -121,7 +121,7 @@ public class XmlElementDescriptorImpl implements XmlElementDescriptor {
|
||||
result.add(element);
|
||||
}
|
||||
}
|
||||
else if (token.getTokenType() == XmlToken.XML_CONTENT_ANY) {
|
||||
else if (token.getTokenType() == XmlTokenType.XML_CONTENT_ANY) {
|
||||
XmlElementDescriptor[] elements = ((XmlNSDescriptorImpl) NSDescriptor).getElements();
|
||||
result.addAll(Arrays.asList(elements));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user