mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-26 19:06:24 +07:00
Untangle Java-based parsers
This commit is contained in:
@@ -34,15 +34,12 @@ import static com.intellij.lang.PsiBuilderUtil.nextTokenType;
|
||||
import static com.intellij.lang.java.parser.JavaParserUtil.*;
|
||||
|
||||
public class DeclarationParser {
|
||||
private final ExpressionParser myExpressionParser;
|
||||
private final StatementParser myStatementParser;
|
||||
private final ReferenceParser myReferenceParser;
|
||||
|
||||
public enum Context {
|
||||
FILE, CLASS, CODE_BLOCK, ANNOTATION_INTERFACE
|
||||
}
|
||||
|
||||
private static final TokenSet AFTER_END_DECLARATION_SET = TokenSet.create(JavaElementType.FIELD, JavaElementType.METHOD);
|
||||
private static final TokenSet AFTER_END_DECLARATION_SET = TokenSet.create(
|
||||
JavaElementType.FIELD, JavaElementType.METHOD);
|
||||
private static final TokenSet BEFORE_LBRACE_ELEMENTS_SET = TokenSet.create(
|
||||
JavaTokenType.IDENTIFIER, JavaTokenType.COMMA, JavaTokenType.EXTENDS_KEYWORD, JavaTokenType.IMPLEMENTS_KEYWORD);
|
||||
private static final TokenSet APPEND_TO_METHOD_SET = TokenSet.create(
|
||||
@@ -51,22 +48,10 @@ public class DeclarationParser {
|
||||
private static final String WHITESPACES = "\n\r \t";
|
||||
private static final String LINE_ENDS = "\n\r";
|
||||
|
||||
public DeclarationParser() {
|
||||
myReferenceParser = new ReferenceParser(this);
|
||||
myExpressionParser = new ExpressionParser(this, myReferenceParser);
|
||||
myStatementParser = new StatementParser(this, myExpressionParser, myReferenceParser);
|
||||
}
|
||||
private final JavaParser myParser;
|
||||
|
||||
public ReferenceParser getReferenceParser() {
|
||||
return myReferenceParser;
|
||||
}
|
||||
|
||||
public ExpressionParser getExpressionParser() {
|
||||
return myExpressionParser;
|
||||
}
|
||||
|
||||
public StatementParser getStatementParser() {
|
||||
return myStatementParser;
|
||||
public DeclarationParser(@NotNull final JavaParser javaParser) {
|
||||
myParser = javaParser;
|
||||
}
|
||||
|
||||
public void parseClassBodyWithBraces(final PsiBuilder builder, final boolean isAnnotation, final boolean isEnum) {
|
||||
@@ -96,9 +81,10 @@ public class DeclarationParser {
|
||||
return null;
|
||||
}
|
||||
|
||||
myReferenceParser.parseTypeParameters(builder);
|
||||
myReferenceParser.parseReferenceList(builder, JavaTokenType.EXTENDS_KEYWORD, JavaElementType.EXTENDS_LIST, JavaTokenType.COMMA);
|
||||
myReferenceParser.parseReferenceList(builder, JavaTokenType.IMPLEMENTS_KEYWORD, JavaElementType.IMPLEMENTS_LIST, JavaTokenType.COMMA);
|
||||
final ReferenceParser refParser = myParser.getReferenceParser();
|
||||
refParser.parseTypeParameters(builder);
|
||||
refParser.parseReferenceList(builder, JavaTokenType.EXTENDS_KEYWORD, JavaElementType.EXTENDS_LIST, JavaTokenType.COMMA);
|
||||
refParser.parseReferenceList(builder, JavaTokenType.IMPLEMENTS_KEYWORD, JavaElementType.IMPLEMENTS_LIST, JavaTokenType.COMMA);
|
||||
|
||||
if (builder.getTokenType() != JavaTokenType.LBRACE) {
|
||||
final PsiBuilder.Marker error = builder.mark();
|
||||
@@ -173,7 +159,7 @@ public class DeclarationParser {
|
||||
|
||||
if (expect(builder, JavaTokenType.IDENTIFIER)) {
|
||||
if (builder.getTokenType() == JavaTokenType.LPARENTH) {
|
||||
myExpressionParser.parseArgumentList(builder);
|
||||
myParser.getExpressionParser().parseArgumentList(builder);
|
||||
}
|
||||
else {
|
||||
emptyElement(builder, JavaElementType.EXPRESSION_LIST);
|
||||
@@ -225,7 +211,7 @@ public class DeclarationParser {
|
||||
}
|
||||
|
||||
// adding a reference, not simple tokens allows "Browse ..." to work well
|
||||
final PsiBuilder.Marker ref = myReferenceParser.parseJavaCodeReference(builder, true, true, false, false, false);
|
||||
final PsiBuilder.Marker ref = myParser.getReferenceParser().parseJavaCodeReference(builder, true, true, false, false, false);
|
||||
if (ref == null) {
|
||||
builder.advanceLexer();
|
||||
}
|
||||
@@ -281,7 +267,7 @@ public class DeclarationParser {
|
||||
|
||||
PsiBuilder.Marker typeParams = null;
|
||||
if (builder.getTokenType() == JavaTokenType.LT) {
|
||||
typeParams = myReferenceParser.parseTypeParameters(builder);
|
||||
typeParams = myParser.getReferenceParser().parseTypeParameters(builder);
|
||||
}
|
||||
|
||||
if (context == Context.FILE) {
|
||||
@@ -322,7 +308,7 @@ public class DeclarationParser {
|
||||
return modList;
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker codeBlock = myStatementParser.parseCodeBlock(builder);
|
||||
final PsiBuilder.Marker codeBlock = myParser.getStatementParser().parseCodeBlock(builder);
|
||||
assert codeBlock != null : builder.getOriginalText();
|
||||
|
||||
if (typeParams != null) {
|
||||
@@ -377,7 +363,7 @@ public class DeclarationParser {
|
||||
|
||||
@NotNull
|
||||
private PsiBuilder.Marker parseTypeNotNull(final PsiBuilder builder) {
|
||||
final PsiBuilder.Marker type = myReferenceParser.parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD);
|
||||
final PsiBuilder.Marker type = myParser.getReferenceParser().parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD);
|
||||
assert type != null : builder.getOriginalText();
|
||||
return type;
|
||||
}
|
||||
@@ -432,7 +418,8 @@ public class DeclarationParser {
|
||||
}
|
||||
}
|
||||
|
||||
myReferenceParser.parseReferenceList(builder, JavaTokenType.THROWS_KEYWORD, JavaElementType.THROWS_LIST, JavaTokenType.COMMA);
|
||||
myParser.getReferenceParser()
|
||||
.parseReferenceList(builder, JavaTokenType.THROWS_KEYWORD, JavaElementType.THROWS_LIST, JavaTokenType.COMMA);
|
||||
|
||||
final boolean hasDefault = expect(builder, JavaTokenType.DEFAULT_KEYWORD);
|
||||
if (hasDefault && anno) {
|
||||
@@ -461,7 +448,7 @@ public class DeclarationParser {
|
||||
error(builder, JavaErrorMessages.message("expected.lbrace"));
|
||||
}
|
||||
if (!expect(builder, JavaTokenType.SEMICOLON) && builder.getTokenType() == JavaTokenType.LBRACE) {
|
||||
myStatementParser.parseCodeBlock(builder);
|
||||
myParser.getStatementParser().parseCodeBlock(builder);
|
||||
}
|
||||
|
||||
done(declaration, anno ? JavaElementType.ANNOTATION_METHOD : JavaElementType.METHOD);
|
||||
@@ -558,12 +545,14 @@ public class DeclarationParser {
|
||||
}
|
||||
|
||||
// adding a reference, not simple tokens allows "Browse .." to work well
|
||||
final PsiBuilder.Marker ref = myReferenceParser.parseJavaCodeReference(builder, true, true, false, false, false);
|
||||
final PsiBuilder.Marker ref = myParser.getReferenceParser().parseJavaCodeReference(builder, true, true, false, false, false);
|
||||
if (ref == null && builder.getTokenType() != null) {
|
||||
builder.advanceLexer();
|
||||
}
|
||||
}
|
||||
|
||||
// todo: false positive
|
||||
//noinspection ConstantConditions
|
||||
if (invalidElements != null) {
|
||||
invalidElements.error(errorMessage);
|
||||
}
|
||||
@@ -594,7 +583,7 @@ public class DeclarationParser {
|
||||
int flags = ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD;
|
||||
if (ellipsis) flags |= ReferenceParser.ELLIPSIS;
|
||||
if (disjunctiveType) flags |= ReferenceParser.DISJUNCTIONS;
|
||||
final ReferenceParser.TypeInfo typeInfo = myReferenceParser.parseTypeInfo(builder, flags);
|
||||
final ReferenceParser.TypeInfo typeInfo = myParser.getReferenceParser().parseTypeInfo(builder, flags);
|
||||
|
||||
if (typeInfo == null) {
|
||||
if (modListInfo.second) {
|
||||
@@ -621,7 +610,7 @@ public class DeclarationParser {
|
||||
}
|
||||
|
||||
if (expectOrError(builder, JavaTokenType.EQ, "expected.eq")) {
|
||||
if (myExpressionParser.parse(builder) == null) {
|
||||
if (myParser.getExpressionParser().parse(builder) == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.expression"));
|
||||
}
|
||||
}
|
||||
@@ -659,7 +648,7 @@ public class DeclarationParser {
|
||||
}
|
||||
|
||||
if (expect(builder, JavaTokenType.EQ)) {
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr != null) {
|
||||
shouldRollback = false;
|
||||
}
|
||||
@@ -756,7 +745,7 @@ public class DeclarationParser {
|
||||
final PsiBuilder.Marker anno = builder.mark();
|
||||
builder.advanceLexer();
|
||||
|
||||
final PsiBuilder.Marker classRef = myReferenceParser.parseJavaCodeReference(builder, true, false, false, false, false);
|
||||
final PsiBuilder.Marker classRef = myParser.getReferenceParser().parseJavaCodeReference(builder, true, false, false, false, false);
|
||||
if (classRef == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.class.reference"));
|
||||
}
|
||||
@@ -860,7 +849,7 @@ public class DeclarationParser {
|
||||
result = parseAnnotationArrayInitializer(builder);
|
||||
}
|
||||
else {
|
||||
result = myExpressionParser.parseConditional(builder);
|
||||
result = myParser.getExpressionParser().parseConditional(builder);
|
||||
}
|
||||
|
||||
if (result == null) {
|
||||
|
||||
@@ -30,11 +30,7 @@ import org.jetbrains.annotations.Nullable;
|
||||
import static com.intellij.lang.PsiBuilderUtil.expect;
|
||||
import static com.intellij.lang.java.parser.JavaParserUtil.*;
|
||||
|
||||
|
||||
public class ExpressionParser {
|
||||
private final DeclarationParser myDeclarationParser;
|
||||
private final ReferenceParser myReferenceParser;
|
||||
|
||||
private enum ExprType {
|
||||
CONDITIONAL_OR, CONDITIONAL_AND, OR, XOR, AND, EQUALITY, RELATIONAL, SHIFT, ADDITIVE, MULTIPLICATIVE, UNARY, TYPE
|
||||
}
|
||||
@@ -64,13 +60,10 @@ public class ExpressionParser {
|
||||
JavaTokenType.IDENTIFIER, TokenType.BAD_CHARACTER, JavaTokenType.COMMA, JavaTokenType.INTEGER_LITERAL, JavaTokenType.STRING_LITERAL);
|
||||
private static final TokenSet THIS_OR_SUPER = TokenSet.create(JavaTokenType.THIS_KEYWORD, JavaTokenType.SUPER_KEYWORD);
|
||||
|
||||
public ExpressionParser(DeclarationParser declarationParser, ReferenceParser referenceParser) {
|
||||
myDeclarationParser = declarationParser;
|
||||
myReferenceParser = referenceParser;
|
||||
}
|
||||
private final JavaParser myParser;
|
||||
|
||||
public ExpressionParser() {
|
||||
this(new DeclarationParser(), new ReferenceParser());
|
||||
public ExpressionParser(@NotNull final JavaParser javaParser) {
|
||||
myParser = javaParser;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@@ -171,7 +164,7 @@ public class ExpressionParser {
|
||||
return parseUnary(builder);
|
||||
|
||||
case TYPE:
|
||||
return myReferenceParser.parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD);
|
||||
return myParser.getReferenceParser().parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD);
|
||||
|
||||
default:
|
||||
assert false : "Unexpected type: " + type;
|
||||
@@ -270,13 +263,14 @@ public class ExpressionParser {
|
||||
final PsiBuilder.Marker typeCast = builder.mark();
|
||||
builder.advanceLexer();
|
||||
|
||||
final ReferenceParser.TypeInfo typeInfo = myReferenceParser.parseTypeInfo(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD);
|
||||
final ReferenceParser.TypeInfo typeInfo = myParser.getReferenceParser().parseTypeInfo(builder,
|
||||
ReferenceParser.EAT_LAST_DOT |
|
||||
ReferenceParser.WILDCARD);
|
||||
|
||||
if (typeInfo == null || builder.getTokenType() != JavaTokenType.RPARENTH) {
|
||||
if (typeInfo == null || !expect(builder, JavaTokenType.RPARENTH)) {
|
||||
typeCast.rollbackTo();
|
||||
return parsePostfix(builder);
|
||||
}
|
||||
builder.advanceLexer();
|
||||
|
||||
if (PREF_ARITHMETIC_OPS.contains(builder.getTokenType())) {
|
||||
if (!typeInfo.isPrimitive) {
|
||||
@@ -375,7 +369,7 @@ public class ExpressionParser {
|
||||
final int offset = builder.getCurrentOffset();
|
||||
startMarker.rollbackTo();
|
||||
|
||||
final PsiBuilder.Marker ref = myReferenceParser.parseJavaCodeReference(builder, false, true, false, false, false);
|
||||
final PsiBuilder.Marker ref = myParser.getReferenceParser().parseJavaCodeReference(builder, false, true, false, false, false);
|
||||
if (ref == null || builder.getTokenType() != JavaTokenType.DOT || builder.getCurrentOffset() != dotOffset) {
|
||||
copy.rollbackTo();
|
||||
return parsePrimary(builder, BreakPoint.P2, offset);
|
||||
@@ -402,7 +396,7 @@ public class ExpressionParser {
|
||||
else {
|
||||
dotPos.drop();
|
||||
final PsiBuilder.Marker refExpr = expr.precede();
|
||||
myReferenceParser.parseReferenceParameterList(builder, false, false);
|
||||
myParser.getReferenceParser().parseReferenceParameterList(builder, false, false);
|
||||
|
||||
if (!expectOrError(builder, JavaTokenType.IDENTIFIER, "expected.identifier")) {
|
||||
refExpr.done(JavaElementType.REFERENCE_EXPRESSION);
|
||||
@@ -547,7 +541,7 @@ public class ExpressionParser {
|
||||
final boolean primitive = tokenType != JavaTokenType.IDENTIFIER;
|
||||
final PsiBuilder.Marker mark = builder.mark();
|
||||
|
||||
final ReferenceParser.TypeInfo typeInfo = myReferenceParser.parseTypeInfo(builder, 0);
|
||||
final ReferenceParser.TypeInfo typeInfo = myParser.getReferenceParser().parseTypeInfo(builder, 0);
|
||||
if (typeInfo != null && (primitive || !typeInfo.hasErrors && typeInfo.isParameterized)) {
|
||||
final PsiBuilder.Marker result = continueClassAccessOrMethodReference(builder, mark, primitive);
|
||||
if (result != null) return result;
|
||||
@@ -558,7 +552,7 @@ public class ExpressionParser {
|
||||
|
||||
PsiBuilder.Marker annotation = null;
|
||||
if (tokenType == JavaTokenType.AT) {
|
||||
annotation = myDeclarationParser.parseAnnotations(builder);
|
||||
annotation = myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
tokenType = builder.getTokenType();
|
||||
}
|
||||
|
||||
@@ -588,7 +582,7 @@ public class ExpressionParser {
|
||||
if (tokenType == JavaTokenType.LT) {
|
||||
expr = builder.mark();
|
||||
|
||||
if (!myReferenceParser.parseReferenceParameterList(builder, false, false)) {
|
||||
if (!myParser.getReferenceParser().parseReferenceParameterList(builder, false, false)) {
|
||||
expr.rollbackTo();
|
||||
return null;
|
||||
}
|
||||
@@ -682,14 +676,14 @@ public class ExpressionParser {
|
||||
final PsiBuilder.Marker newExpr = (start != null ? start.precede() : builder.mark());
|
||||
builder.advanceLexer();
|
||||
|
||||
myReferenceParser.parseReferenceParameterList(builder, false, true);
|
||||
myParser.getReferenceParser().parseReferenceParameterList(builder, false, true);
|
||||
|
||||
final PsiBuilder.Marker refOrType;
|
||||
final boolean parseAnnotations = areTypeAnnotationsSupported(builder) && builder.getTokenType() == JavaTokenType.AT;
|
||||
|
||||
final IElementType tokenType = builder.getTokenType();
|
||||
if (tokenType == JavaTokenType.IDENTIFIER || parseAnnotations) {
|
||||
refOrType = myReferenceParser.parseJavaCodeReference(builder, true, true, parseAnnotations, true, true);
|
||||
refOrType = myParser.getReferenceParser().parseJavaCodeReference(builder, true, true, parseAnnotations, true, true);
|
||||
if (refOrType == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.identifier"));
|
||||
newExpr.done(JavaElementType.NEW_EXPRESSION);
|
||||
@@ -710,7 +704,7 @@ public class ExpressionParser {
|
||||
parseArgumentList(builder);
|
||||
if (builder.getTokenType() == JavaTokenType.LBRACE) {
|
||||
final PsiBuilder.Marker classElement = refOrType.precede();
|
||||
myDeclarationParser.parseClassBodyWithBraces(builder, false, false);
|
||||
myParser.getDeclarationParser().parseClassBodyWithBraces(builder, false, false);
|
||||
classElement.done(JavaElementType.ANONYMOUS_CLASS);
|
||||
}
|
||||
}
|
||||
@@ -761,7 +755,7 @@ public class ExpressionParser {
|
||||
final PsiBuilder.Marker expr = builder.mark();
|
||||
|
||||
final boolean primitive = ElementType.PRIMITIVE_TYPE_BIT_SET.contains(builder.getTokenType());
|
||||
if (myReferenceParser.parseType(builder, 0) == null) {
|
||||
if (myParser.getReferenceParser().parseType(builder, 0) == null) {
|
||||
expr.drop();
|
||||
return null;
|
||||
}
|
||||
@@ -809,7 +803,7 @@ public class ExpressionParser {
|
||||
private PsiBuilder.Marker parseMethodReference(final PsiBuilder builder, final PsiBuilder.Marker start) {
|
||||
builder.advanceLexer();
|
||||
|
||||
myReferenceParser.parseReferenceParameterList(builder, false, false);
|
||||
myParser.getReferenceParser().parseReferenceParameterList(builder, false, false);
|
||||
|
||||
if (!expect(builder, JavaTokenType.IDENTIFIER) && !expect(builder, JavaTokenType.NEW_KEYWORD)) {
|
||||
error(builder, JavaErrorMessages.message("expected.identifier"));
|
||||
|
||||
@@ -30,23 +30,15 @@ import org.jetbrains.annotations.Nullable;
|
||||
import static com.intellij.lang.PsiBuilderUtil.expect;
|
||||
import static com.intellij.lang.java.parser.JavaParserUtil.*;
|
||||
|
||||
|
||||
public class FileParser {
|
||||
public static final FileParser INSTANCE = new FileParser();
|
||||
private final ReferenceParser myReferenceParser;
|
||||
private final DeclarationParser myDeclarationParser;
|
||||
|
||||
private static final TokenSet IMPORT_LIST_STOPPER_SET = TokenSet.orSet(
|
||||
ElementType.MODIFIER_BIT_SET,
|
||||
TokenSet.create(JavaTokenType.CLASS_KEYWORD, JavaTokenType.INTERFACE_KEYWORD, JavaTokenType.ENUM_KEYWORD, JavaTokenType.AT));
|
||||
|
||||
private FileParser() {
|
||||
this(JavaParsers.DECLARATION_PARSER, JavaParsers.REFERENCE_PARSER);
|
||||
}
|
||||
private final JavaParser myParser;
|
||||
|
||||
protected FileParser(DeclarationParser declarationParser, ReferenceParser referenceParser) {
|
||||
myDeclarationParser = declarationParser;
|
||||
myReferenceParser = referenceParser;
|
||||
public FileParser(@NotNull final JavaParser javaParser) {
|
||||
myParser = javaParser;
|
||||
}
|
||||
|
||||
public void parse(final PsiBuilder builder) {
|
||||
@@ -113,7 +105,7 @@ public class FileParser {
|
||||
|
||||
@Nullable
|
||||
protected PsiBuilder.Marker parseInitial(PsiBuilder builder) {
|
||||
return myDeclarationParser.parse(builder, DeclarationParser.Context.FILE);
|
||||
return myParser.getDeclarationParser().parse(builder, DeclarationParser.Context.FILE);
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@@ -122,7 +114,7 @@ public class FileParser {
|
||||
|
||||
if (!expect(builder, JavaTokenType.PACKAGE_KEYWORD)) {
|
||||
final PsiBuilder.Marker modList = builder.mark();
|
||||
myDeclarationParser.parseAnnotations(builder);
|
||||
myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
done(modList, JavaElementType.MODIFIER_LIST);
|
||||
if (!expect(builder, JavaTokenType.PACKAGE_KEYWORD)) {
|
||||
statement.rollbackTo();
|
||||
@@ -130,7 +122,7 @@ public class FileParser {
|
||||
}
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker ref = myReferenceParser.parseJavaCodeReference(builder, true, false, false, false, false);
|
||||
final PsiBuilder.Marker ref = myParser.getReferenceParser().parseJavaCodeReference(builder, true, false, false, false, false);
|
||||
if (ref == null) {
|
||||
statement.rollbackTo();
|
||||
return null;
|
||||
@@ -186,7 +178,7 @@ public class FileParser {
|
||||
final boolean isStatic = expect(builder, JavaTokenType.STATIC_KEYWORD);
|
||||
final IElementType type = isStatic ? JavaElementType.IMPORT_STATIC_STATEMENT : JavaElementType.IMPORT_STATEMENT;
|
||||
|
||||
final boolean isOk = myReferenceParser.parseImportCodeReference(builder, isStatic);
|
||||
final boolean isOk = myParser.getReferenceParser().parseImportCodeReference(builder, isStatic);
|
||||
if (isOk) {
|
||||
semicolon(builder);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
* Copyright 2000-2012 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package com.intellij.lang.java.parser;
|
||||
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
public class JavaParser {
|
||||
public static final JavaParser INSTANCE = new JavaParser();
|
||||
|
||||
private final FileParser myFileParser;
|
||||
private final DeclarationParser myDeclarationParser;
|
||||
private final StatementParser myStatementParser;
|
||||
private final ExpressionParser myExpressionParser;
|
||||
private final ReferenceParser myReferenceParser;
|
||||
|
||||
public JavaParser() {
|
||||
myFileParser = new FileParser(this);
|
||||
myDeclarationParser = new DeclarationParser(this);
|
||||
myStatementParser = new StatementParser(this);
|
||||
myExpressionParser = new ExpressionParser(this);
|
||||
myReferenceParser = new ReferenceParser(this);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public FileParser getFileParser() {
|
||||
return myFileParser;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public DeclarationParser getDeclarationParser() {
|
||||
return myDeclarationParser;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public StatementParser getStatementParser() {
|
||||
return myStatementParser;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ExpressionParser getExpressionParser() {
|
||||
return myExpressionParser;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public ReferenceParser getReferenceParser() {
|
||||
return myReferenceParser;
|
||||
}
|
||||
}
|
||||
@@ -43,7 +43,6 @@ import org.jetbrains.annotations.PropertyKey;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
|
||||
public class JavaParserUtil {
|
||||
private static final Key<LanguageLevel> LANG_LEVEL_KEY = Key.create("JavaParserUtil.LanguageLevel");
|
||||
private static final Key<Boolean> DEEP_PARSE_BLOCKS_IN_STATEMENTS = Key.create("JavaParserUtil.ParserExtender");
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
/*
|
||||
* Copyright 2000-2011 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package com.intellij.lang.java.parser;
|
||||
|
||||
/**
|
||||
* @author Dmitry Avdeev
|
||||
* Date: 11/19/11
|
||||
*/
|
||||
public class JavaParsers {
|
||||
public static final DeclarationParser DECLARATION_PARSER = new DeclarationParser();
|
||||
public static final ExpressionParser EXPRESSION_PARSER = new ExpressionParser();
|
||||
public static final ReferenceParser REFERENCE_PARSER = new ReferenceParser();
|
||||
public static final StatementParser STATEMENT_PARSER = new StatementParser();
|
||||
}
|
||||
@@ -51,12 +51,12 @@ public class JavadocParser {
|
||||
private JavadocParser() { }
|
||||
|
||||
public static void parseJavadocReference(@NotNull final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseJavaCodeReference(builder, true, true, false, false, false);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseJavaCodeReference(builder, true, true, false, false, false);
|
||||
swallowTokens(builder);
|
||||
}
|
||||
|
||||
public static void parseJavadocType(@NotNull final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.ELLIPSIS | ReferenceParser.WILDCARD);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.ELLIPSIS | ReferenceParser.WILDCARD);
|
||||
swallowTokens(builder);
|
||||
}
|
||||
|
||||
|
||||
@@ -30,10 +30,7 @@ import static com.intellij.lang.PsiBuilderUtil.nextTokenType;
|
||||
import static com.intellij.lang.java.parser.JavaParserUtil.*;
|
||||
import static com.intellij.util.BitUtil.isSet;
|
||||
|
||||
|
||||
public class ReferenceParser {
|
||||
private final DeclarationParser myDeclarationParser;
|
||||
|
||||
public static final int EAT_LAST_DOT = 0x01;
|
||||
public static final int ELLIPSIS = 0x02;
|
||||
public static final int WILDCARD = 0x04;
|
||||
@@ -51,12 +48,10 @@ public class ReferenceParser {
|
||||
|
||||
private static final TokenSet WILDCARD_KEYWORD_SET = TokenSet.create(JavaTokenType.EXTENDS_KEYWORD, JavaTokenType.SUPER_KEYWORD);
|
||||
|
||||
public ReferenceParser(DeclarationParser declarationParser) {
|
||||
myDeclarationParser = declarationParser;
|
||||
}
|
||||
private final JavaParser myParser;
|
||||
|
||||
public ReferenceParser() {
|
||||
this(new DeclarationParser());
|
||||
public ReferenceParser(@NotNull final JavaParser javaParser) {
|
||||
myParser = javaParser;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@@ -67,7 +62,8 @@ public class ReferenceParser {
|
||||
|
||||
@Nullable
|
||||
public TypeInfo parseTypeInfo(final PsiBuilder builder, final int flags) {
|
||||
final TypeInfo typeInfo = parseTypeInfo(builder, isSet(flags, EAT_LAST_DOT), isSet(flags, WILDCARD), false, isSet(flags, DIAMONDS), isSet(flags, ELLIPSIS));
|
||||
final TypeInfo typeInfo = parseTypeInfo(builder, isSet(flags, EAT_LAST_DOT), isSet(flags, WILDCARD), false, isSet(flags, DIAMONDS),
|
||||
isSet(flags, ELLIPSIS));
|
||||
|
||||
if (typeInfo != null && isSet(flags, DISJUNCTIONS) && builder.getTokenType() == JavaTokenType.OR) {
|
||||
typeInfo.marker = typeInfo.marker.precede();
|
||||
@@ -87,8 +83,8 @@ public class ReferenceParser {
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private TypeInfo parseTypeInfo(final PsiBuilder builder,
|
||||
final boolean eatLastDot, final boolean wildcard, final boolean badWildcard, final boolean diamonds, final boolean ellipsis) {
|
||||
private TypeInfo parseTypeInfo(final PsiBuilder builder, final boolean eatLastDot, final boolean wildcard, final boolean badWildcard,
|
||||
final boolean diamonds, final boolean ellipsis) {
|
||||
if (builder.getTokenType() == null) return null;
|
||||
|
||||
final TypeInfo typeInfo = new TypeInfo();
|
||||
@@ -96,7 +92,7 @@ public class ReferenceParser {
|
||||
final boolean annotationsSupported = areTypeAnnotationsSupported(builder);
|
||||
PsiBuilder.Marker type = builder.mark();
|
||||
if (annotationsSupported) {
|
||||
myDeclarationParser.parseAnnotations(builder);
|
||||
myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
}
|
||||
|
||||
final IElementType tokenType = builder.getTokenType();
|
||||
@@ -125,7 +121,7 @@ public class ReferenceParser {
|
||||
while (true) {
|
||||
type.done(JavaElementType.TYPE);
|
||||
if (annotationsSupported) {
|
||||
myDeclarationParser.parseAnnotations(builder);
|
||||
myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker bracket = builder.mark();
|
||||
@@ -193,7 +189,7 @@ public class ReferenceParser {
|
||||
PsiBuilder.Marker refElement = builder.mark();
|
||||
|
||||
if (annotations) {
|
||||
myDeclarationParser.parseAnnotations(builder);
|
||||
myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
}
|
||||
|
||||
if (!expect(builder, JavaTokenType.IDENTIFIER)) {
|
||||
@@ -344,7 +340,7 @@ public class ReferenceParser {
|
||||
public PsiBuilder.Marker parseTypeParameter(final PsiBuilder builder) {
|
||||
final PsiBuilder.Marker param = builder.mark();
|
||||
|
||||
myDeclarationParser.parseAnnotations(builder);
|
||||
myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
|
||||
final boolean wild = expect(builder, JavaTokenType.QUEST);
|
||||
if (!wild && !expect(builder, JavaTokenType.IDENTIFIER)) {
|
||||
|
||||
@@ -32,28 +32,19 @@ import java.util.List;
|
||||
import static com.intellij.lang.PsiBuilderUtil.*;
|
||||
import static com.intellij.lang.java.parser.JavaParserUtil.*;
|
||||
|
||||
|
||||
public class StatementParser {
|
||||
private final ExpressionParser myExpressionParser;
|
||||
private final DeclarationParser myDeclarationParser;
|
||||
private final ReferenceParser myReferenceParser;
|
||||
|
||||
public StatementParser(DeclarationParser declarationParser, ExpressionParser expressionParser, ReferenceParser referenceParser) {
|
||||
myDeclarationParser = declarationParser;
|
||||
myExpressionParser = expressionParser;
|
||||
myReferenceParser = referenceParser;
|
||||
}
|
||||
|
||||
public StatementParser() {
|
||||
this(new DeclarationParser(), new ExpressionParser(), new ReferenceParser());
|
||||
}
|
||||
|
||||
private enum BraceMode {
|
||||
TILL_FIRST, TILL_LAST
|
||||
}
|
||||
|
||||
private static final TokenSet TRY_CLOSERS_SET = TokenSet.create(JavaTokenType.CATCH_KEYWORD, JavaTokenType.FINALLY_KEYWORD);
|
||||
|
||||
private final JavaParser myParser;
|
||||
|
||||
public StatementParser(@NotNull final JavaParser javaParser) {
|
||||
myParser = javaParser;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public PsiBuilder.Marker parseCodeBlock(final PsiBuilder builder) {
|
||||
return parseCodeBlock(builder, false);
|
||||
@@ -236,15 +227,15 @@ public class StatementParser {
|
||||
}
|
||||
else if (tokenType == JavaTokenType.IDENTIFIER || tokenType == JavaTokenType.AT) {
|
||||
final PsiBuilder.Marker refPos = builder.mark();
|
||||
myDeclarationParser.parseAnnotations(builder);
|
||||
myParser.getDeclarationParser().parseAnnotations(builder);
|
||||
skipQualifiedName(builder);
|
||||
final IElementType suspectedLT = builder.getTokenType();
|
||||
refPos.rollbackTo();
|
||||
if (suspectedLT == JavaTokenType.LT) {
|
||||
final PsiBuilder.Marker declStatement = builder.mark();
|
||||
final PsiBuilder.Marker decl = myDeclarationParser.parse(builder, DeclarationParser.Context.CODE_BLOCK);
|
||||
final PsiBuilder.Marker decl = myParser.getDeclarationParser().parse(builder, DeclarationParser.Context.CODE_BLOCK);
|
||||
if (decl == null) {
|
||||
PsiBuilder.Marker marker = myReferenceParser.parseType(builder, 0);
|
||||
PsiBuilder.Marker marker = myParser.getReferenceParser().parseType(builder, 0);
|
||||
error(builder, JavaErrorMessages.message("expected.identifier"));
|
||||
if (marker == null) builder.advanceLexer();
|
||||
}
|
||||
@@ -254,7 +245,7 @@ public class StatementParser {
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker pos = builder.mark();
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
|
||||
if (expr != null) {
|
||||
int count = 1;
|
||||
@@ -263,7 +254,7 @@ public class StatementParser {
|
||||
while (builder.getTokenType() == JavaTokenType.COMMA) {
|
||||
final PsiBuilder.Marker commaPos = builder.mark();
|
||||
builder.advanceLexer();
|
||||
final PsiBuilder.Marker expr1 = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr1 = myParser.getExpressionParser().parse(builder);
|
||||
if (expr1 == null) {
|
||||
commaPos.rollbackTo();
|
||||
break;
|
||||
@@ -290,7 +281,7 @@ public class StatementParser {
|
||||
pos.drop();
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker decl = myDeclarationParser.parse(builder, DeclarationParser.Context.CODE_BLOCK);
|
||||
final PsiBuilder.Marker decl = myParser.getDeclarationParser().parse(builder, DeclarationParser.Context.CODE_BLOCK);
|
||||
if (decl != null) {
|
||||
final PsiBuilder.Marker statement = decl.precede();
|
||||
done(statement, JavaElementType.DECLARATION_STATEMENT);
|
||||
@@ -307,7 +298,7 @@ public class StatementParser {
|
||||
|
||||
if (expr != null) {
|
||||
final PsiBuilder.Marker statement = builder.mark();
|
||||
myExpressionParser.parse(builder);
|
||||
myParser.getExpressionParser().parse(builder);
|
||||
semicolon(builder);
|
||||
done(statement, JavaElementType.EXPRESSION_STATEMENT);
|
||||
return statement;
|
||||
@@ -385,7 +376,7 @@ public class StatementParser {
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker afterParenth = builder.mark();
|
||||
final PsiBuilder.Marker param = myDeclarationParser.parseParameter(builder, false, false);
|
||||
final PsiBuilder.Marker param = myParser.getDeclarationParser().parseParameter(builder, false, false);
|
||||
if (param == null || exprType(param) != JavaElementType.PARAMETER || builder.getTokenType() != JavaTokenType.COLON) {
|
||||
afterParenth.rollbackTo();
|
||||
return parseForLoopFromInitialization(builder, statement);
|
||||
@@ -407,7 +398,7 @@ public class StatementParser {
|
||||
}
|
||||
}
|
||||
else {
|
||||
myExpressionParser.parse(builder);
|
||||
myParser.getExpressionParser().parse(builder);
|
||||
if (!expect(builder, JavaTokenType.SEMICOLON)) {
|
||||
error(builder, JavaErrorMessages.message("expected.semicolon"));
|
||||
if (!expect(builder, JavaTokenType.RPARENTH)) {
|
||||
@@ -435,7 +426,7 @@ public class StatementParser {
|
||||
}
|
||||
|
||||
private void parseExpressionOrExpressionList(final PsiBuilder builder) {
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr == null) return;
|
||||
|
||||
final PsiBuilder.Marker expressionStatement;
|
||||
@@ -449,7 +440,7 @@ public class StatementParser {
|
||||
|
||||
do {
|
||||
builder.advanceLexer();
|
||||
final PsiBuilder.Marker nextExpression = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker nextExpression = myParser.getExpressionParser().parse(builder);
|
||||
if (nextExpression == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.expression"));
|
||||
}
|
||||
@@ -465,7 +456,7 @@ public class StatementParser {
|
||||
private PsiBuilder.Marker parseForEachFromColon(PsiBuilder builder, PsiBuilder.Marker statement) {
|
||||
builder.advanceLexer();
|
||||
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.expression"));
|
||||
}
|
||||
@@ -536,7 +527,7 @@ public class StatementParser {
|
||||
builder.advanceLexer();
|
||||
|
||||
if (isCase) {
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr == null) {
|
||||
statement.rollbackTo();
|
||||
return null;
|
||||
@@ -574,7 +565,7 @@ public class StatementParser {
|
||||
final PsiBuilder.Marker statement = builder.mark();
|
||||
builder.advanceLexer();
|
||||
|
||||
myExpressionParser.parse(builder);
|
||||
myParser.getExpressionParser().parse(builder);
|
||||
|
||||
semicolon(builder);
|
||||
done(statement, JavaElementType.RETURN_STATEMENT);
|
||||
@@ -586,7 +577,7 @@ public class StatementParser {
|
||||
final PsiBuilder.Marker statement = builder.mark();
|
||||
builder.advanceLexer();
|
||||
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.expression"));
|
||||
done(statement, JavaElementType.THROW_STATEMENT);
|
||||
@@ -624,7 +615,7 @@ public class StatementParser {
|
||||
|
||||
final boolean hasResourceList = builder.getTokenType() == JavaTokenType.LPARENTH;
|
||||
if (hasResourceList) {
|
||||
myDeclarationParser.parseResourceList(builder);
|
||||
myParser.getDeclarationParser().parseResourceList(builder);
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker tryBlock = parseCodeBlock(builder, true);
|
||||
@@ -666,7 +657,7 @@ public class StatementParser {
|
||||
return false;
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker param = myDeclarationParser.parseParameter(builder, false, true);
|
||||
final PsiBuilder.Marker param = myParser.getDeclarationParser().parseParameter(builder, false, true);
|
||||
if (param == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.parameter"));
|
||||
}
|
||||
@@ -693,7 +684,7 @@ public class StatementParser {
|
||||
final PsiBuilder.Marker statement = builder.mark();
|
||||
builder.advanceLexer();
|
||||
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.boolean.expression"));
|
||||
done(statement, JavaElementType.ASSERT_STATEMENT);
|
||||
@@ -701,7 +692,7 @@ public class StatementParser {
|
||||
}
|
||||
|
||||
if (expect(builder, JavaTokenType.COLON)) {
|
||||
final PsiBuilder.Marker expr2 = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr2 = myParser.getExpressionParser().parse(builder);
|
||||
if (expr2 == null) {
|
||||
error(builder, JavaErrorMessages.message("expected.expression"));
|
||||
done(statement, JavaElementType.ASSERT_STATEMENT);
|
||||
@@ -729,7 +720,7 @@ public class StatementParser {
|
||||
}
|
||||
|
||||
final PsiBuilder.Marker beforeExpr = builder.mark();
|
||||
final PsiBuilder.Marker expr = myExpressionParser.parse(builder);
|
||||
final PsiBuilder.Marker expr = myParser.getExpressionParser().parse(builder);
|
||||
if (expr == null || builder.getTokenType() == JavaTokenType.SEMICOLON) {
|
||||
beforeExpr.rollbackTo();
|
||||
error(builder, JavaErrorMessages.message("expected.expression"));
|
||||
|
||||
@@ -16,8 +16,8 @@
|
||||
package com.intellij.psi.impl;
|
||||
|
||||
import com.intellij.lang.*;
|
||||
import com.intellij.lang.java.parser.JavaParser;
|
||||
import com.intellij.lang.java.parser.JavaParserUtil;
|
||||
import com.intellij.lang.java.parser.JavaParsers;
|
||||
import com.intellij.lexer.JavaLexer;
|
||||
import com.intellij.lexer.Lexer;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
@@ -721,7 +721,7 @@ public class PsiElementFactoryImpl extends PsiJavaParserFacadeImpl implements Ps
|
||||
private static final JavaParserUtil.ParserWrapper CATCH_SECTION = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.STATEMENT_PARSER.parseCatchBlock(builder);
|
||||
JavaParser.INSTANCE.getStatementParser().parseCatchBlock(builder);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2000-2011 JetBrains s.r.o.
|
||||
* Copyright 2000-2012 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -53,92 +53,92 @@ public class PsiJavaParserFacadeImpl implements PsiJavaParserFacade {
|
||||
private static final JavaParserUtil.ParserWrapper ANNOTATION = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.DECLARATION_PARSER.parseAnnotation(builder);
|
||||
JavaParser.INSTANCE.getDeclarationParser().parseAnnotation(builder);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper PARAMETER = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.DECLARATION_PARSER.parseParameter(builder, true, false);
|
||||
JavaParser.INSTANCE.getDeclarationParser().parseParameter(builder, true, false);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper RESOURCE = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.DECLARATION_PARSER.parseResource(builder);
|
||||
JavaParser.INSTANCE.getDeclarationParser().parseResource(builder);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper TYPE = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.ELLIPSIS |
|
||||
ReferenceParser.WILDCARD | ReferenceParser.DISJUNCTIONS);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.ELLIPSIS |
|
||||
ReferenceParser.WILDCARD | ReferenceParser.DISJUNCTIONS);
|
||||
}
|
||||
};
|
||||
|
||||
public static final JavaParserUtil.ParserWrapper REFERENCE = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseJavaCodeReference(builder, false, true, false, false, false);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseJavaCodeReference(builder, false, true, false, false, false);
|
||||
}
|
||||
};
|
||||
|
||||
public static final JavaParserUtil.ParserWrapper DIAMOND_REF = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseJavaCodeReference(builder, false, true, false, false, true);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseJavaCodeReference(builder, false, true, false, false, true);
|
||||
}
|
||||
};
|
||||
|
||||
public static final JavaParserUtil.ParserWrapper STATIC_IMPORT_REF = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseImportCodeReference(builder, true);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseImportCodeReference(builder, true);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper TYPE_PARAMETER = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseTypeParameter(builder);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseTypeParameter(builder);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper DECLARATION = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.DECLARATION_PARSER.parse(builder, DeclarationParser.Context.CLASS);
|
||||
JavaParser.INSTANCE.getDeclarationParser().parse(builder, DeclarationParser.Context.CLASS);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper CODE_BLOCK = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.STATEMENT_PARSER.parseCodeBlockDeep(builder, true);
|
||||
JavaParser.INSTANCE.getStatementParser().parseCodeBlockDeep(builder, true);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper STATEMENT = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.STATEMENT_PARSER.parseStatement(builder);
|
||||
JavaParser.INSTANCE.getStatementParser().parseStatement(builder);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper EXPRESSION = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.EXPRESSION_PARSER.parse(builder);
|
||||
JavaParser.INSTANCE.getExpressionParser().parse(builder);
|
||||
}
|
||||
};
|
||||
|
||||
private static final JavaParserUtil.ParserWrapper ENUM_CONSTANT = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.DECLARATION_PARSER.parseEnumConstant(builder);
|
||||
JavaParser.INSTANCE.getDeclarationParser().parseEnumConstant(builder);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2000-2009 JetBrains s.r.o.
|
||||
* Copyright 2000-2012 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -16,8 +16,8 @@
|
||||
package com.intellij.psi.impl.compiled;
|
||||
|
||||
import com.intellij.lang.PsiBuilder;
|
||||
import com.intellij.lang.java.parser.JavaParser;
|
||||
import com.intellij.lang.java.parser.JavaParserUtil;
|
||||
import com.intellij.lang.java.parser.JavaParsers;
|
||||
import com.intellij.openapi.diagnostic.Logger;
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
import com.intellij.psi.*;
|
||||
@@ -40,7 +40,7 @@ public class ClsParsingUtil {
|
||||
private static final JavaParserUtil.ParserWrapper ANNOTATION_VALUE = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.DECLARATION_PARSER.parseAnnotationValue(builder);
|
||||
JavaParser.INSTANCE.getDeclarationParser().parseAnnotationValue(builder);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -19,7 +19,7 @@ import com.intellij.lang.ASTNode;
|
||||
import com.intellij.lang.LighterASTNode;
|
||||
import com.intellij.lang.PsiBuilder;
|
||||
import com.intellij.lang.java.JavaLanguage;
|
||||
import com.intellij.lang.java.parser.FileParser;
|
||||
import com.intellij.lang.java.parser.JavaParser;
|
||||
import com.intellij.lang.java.parser.JavaParserUtil;
|
||||
import com.intellij.openapi.vfs.VirtualFile;
|
||||
import com.intellij.pom.java.LanguageLevel;
|
||||
@@ -80,7 +80,7 @@ public class JavaFileElementType extends ILightStubFileElementType<PsiJavaFileSt
|
||||
|
||||
private void doParse(final PsiBuilder builder) {
|
||||
final PsiBuilder.Marker root = builder.mark();
|
||||
FileParser.INSTANCE.parse(builder);
|
||||
JavaParser.INSTANCE.getFileParser().parse(builder);
|
||||
root.done(this);
|
||||
}
|
||||
|
||||
|
||||
@@ -153,14 +153,14 @@ public interface JavaElementType {
|
||||
@Override
|
||||
public ASTNode parseContents(final ASTNode chameleon) {
|
||||
final PsiBuilder builder = JavaParserUtil.createBuilder(chameleon);
|
||||
JavaParsers.STATEMENT_PARSER.parseCodeBlockDeep(builder, true);
|
||||
JavaParser.INSTANCE.getStatementParser().parseCodeBlockDeep(builder, true);
|
||||
return builder.getTreeBuilt().getFirstChildNode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public FlyweightCapableTreeStructure<LighterASTNode> parseContents(final LighterLazyParseableNode chameleon) {
|
||||
final PsiBuilder builder = JavaParserUtil.createBuilder(chameleon);
|
||||
JavaParsers.STATEMENT_PARSER.parseCodeBlockDeep(builder, true);
|
||||
JavaParser.INSTANCE.getStatementParser().parseCodeBlockDeep(builder, true);
|
||||
return builder.getLightTree();
|
||||
}
|
||||
|
||||
@@ -193,7 +193,7 @@ public interface JavaElementType {
|
||||
private final JavaParserUtil.ParserWrapper myParser = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.STATEMENT_PARSER.parseStatements(builder);
|
||||
JavaParser.INSTANCE.getStatementParser().parseStatements(builder);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -208,7 +208,7 @@ public interface JavaElementType {
|
||||
private final JavaParserUtil.ParserWrapper myParser = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.EXPRESSION_PARSER.parse(builder);
|
||||
JavaParser.INSTANCE.getExpressionParser().parse(builder);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -223,7 +223,7 @@ public interface JavaElementType {
|
||||
private final JavaParserUtil.ParserWrapper myParser = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseJavaCodeReference(builder, false, true, false, false, false);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseJavaCodeReference(builder, false, true, false, false, false);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -238,8 +238,8 @@ public interface JavaElementType {
|
||||
private final JavaParserUtil.ParserWrapper myParser = new JavaParserUtil.ParserWrapper() {
|
||||
@Override
|
||||
public void parse(final PsiBuilder builder) {
|
||||
JavaParsers.REFERENCE_PARSER.parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.ELLIPSIS |
|
||||
ReferenceParser.WILDCARD | ReferenceParser.DISJUNCTIONS);
|
||||
JavaParser.INSTANCE.getReferenceParser().parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.ELLIPSIS |
|
||||
ReferenceParser.WILDCARD | ReferenceParser.DISJUNCTIONS);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user