org.jetbrains.plugins.groovy.lang.parser.parsing.statements.expressions.arithmetic.PathExpression Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of groovy-psi Show documentation
Show all versions of groovy-psi Show documentation
A packaging of the IntelliJ Community Edition groovy-psi library.
This is release number 1 of trunk branch 142.
The newest version!
/*
* Copyright 2000-2014 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 org.jetbrains.plugins.groovy.lang.parser.parsing.statements.expressions.arithmetic;
import com.intellij.lang.PsiBuilder;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.TokenSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.groovy.GroovyBundle;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyElementType;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
import org.jetbrains.plugins.groovy.lang.lexer.TokenSets;
import org.jetbrains.plugins.groovy.lang.parser.GroovyElementTypes;
import org.jetbrains.plugins.groovy.lang.parser.GroovyParser;
import org.jetbrains.plugins.groovy.lang.parser.parsing.statements.blocks.OpenOrClosableBlock;
import org.jetbrains.plugins.groovy.lang.parser.parsing.statements.expressions.arguments.ArgumentList;
import org.jetbrains.plugins.groovy.lang.parser.parsing.statements.expressions.primary.CompoundStringExpression;
import org.jetbrains.plugins.groovy.lang.parser.parsing.statements.expressions.primary.PrimaryExpression;
import org.jetbrains.plugins.groovy.lang.parser.parsing.types.TypeArguments;
import org.jetbrains.plugins.groovy.lang.parser.parsing.util.ParserUtils;
/**
* @author ilyas
*/
public class PathExpression {
public enum Result {INVOKED_EXPR, METHOD_CALL, WRONG_WAY, LITERAL}
private static final TokenSet DOTS = TokenSet.create(GroovyTokenTypes.mSPREAD_DOT, GroovyTokenTypes.mOPTIONAL_DOT,
GroovyTokenTypes.mMEMBER_POINTER, GroovyTokenTypes.mDOT);
private static final TokenSet PATH_ELEMENT_START = TokenSet.create(GroovyTokenTypes.mSPREAD_DOT, GroovyTokenTypes.mOPTIONAL_DOT,
GroovyTokenTypes.mMEMBER_POINTER, GroovyTokenTypes.mLBRACK,
GroovyTokenTypes.mLPAREN, GroovyTokenTypes.mLCURLY,
GroovyTokenTypes.mDOT);
public static boolean parse(@NotNull PsiBuilder builder, @NotNull GroovyParser parser) {
return parsePathExprQualifierForExprStatement(builder, parser) != Result.WRONG_WAY;
}
/**
* parses method calls with parentheses, property index access, etc
*/
@NotNull
public static Result parsePathExprQualifierForExprStatement(@NotNull PsiBuilder builder, @NotNull GroovyParser parser) {
PsiBuilder.Marker marker = builder.mark();
IElementType qualifierType = PrimaryExpression.parsePrimaryExpression(builder, parser);
if (qualifierType != GroovyElementTypes.WRONGWAY) {
return parseAfterQualifier(builder, parser, marker, qualifierType);
}
else {
marker.drop();
return Result.WRONG_WAY;
}
}
@NotNull
private static Result parseAfterQualifier(@NotNull PsiBuilder builder,
@NotNull GroovyParser parser,
@NotNull PsiBuilder.Marker marker,
@NotNull IElementType qualifierType) {
if (isPathElementStart(builder)) {
if (isLParenthOrLCurlyAfterLiteral(builder, qualifierType)) {
marker.rollbackTo();
PsiBuilder.Marker newMarker = builder.mark();
IElementType newQualifierType = PrimaryExpression.parsePrimaryExpression(builder, parser, true);
assert newQualifierType != GroovyElementTypes.WRONGWAY;
return parseAfterReference(builder, parser, newMarker);
}
else {
return parseAfterReference(builder, parser, marker);
}
}
else {
marker.drop();
if (qualifierType == GroovyElementTypes.LITERAL) return Result.LITERAL;
return Result.INVOKED_EXPR;
}
}
private static boolean isLParenthOrLCurlyAfterLiteral(@NotNull PsiBuilder builder, @NotNull IElementType qualifierType) {
return qualifierType == GroovyElementTypes.LITERAL && (checkForLParenth(builder) || checkForLCurly(builder));
}
@NotNull
private static Result pathElementParse(@NotNull PsiBuilder builder,
@NotNull PsiBuilder.Marker marker,
@NotNull GroovyParser parser,
@NotNull Result result) {
// Property reference
if (DOTS.contains(builder.getTokenType()) || ParserUtils.lookAhead(builder, GroovyTokenTypes.mNLS, GroovyTokenTypes.mDOT)) {
if (ParserUtils.lookAhead(builder, GroovyTokenTypes.mNLS, GroovyTokenTypes.mDOT)) {
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
}
ParserUtils.getToken(builder, DOTS);
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
TypeArguments.parseTypeArguments(builder, true);
GroovyElementType res = namePartParse(builder, parser);
if (res != GroovyElementTypes.WRONGWAY) {
PsiBuilder.Marker newMarker = marker.precede();
marker.done(res);
return parseAfterReference(builder, parser, newMarker);
}
else {
builder.error(GroovyBundle.message("path.selector.expected"));
marker.drop();
return result;
}
}
else if (checkForLParenth(builder)) {
PrimaryExpression.methodCallArgsParse(builder, parser);
return parseAfterArguments(builder, marker, parser);
}
else if (checkForLCurly(builder)) {
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
appendedBlockParse(builder, parser);
return parseAfterArguments(builder, marker, parser);
}
else if (checkForArrayAccess(builder)) {
indexPropertyArgsParse(builder, parser);
PsiBuilder.Marker newMarker = marker.precede();
marker.done(GroovyElementTypes.PATH_INDEX_PROPERTY);
return parseAfterReference(builder, parser, newMarker);
}
else {
marker.drop();
return result;
}
}
@NotNull
private static Result parseAfterReference(@NotNull PsiBuilder builder, @NotNull GroovyParser parser, @NotNull PsiBuilder.Marker newMarker) {
if (checkForLCurly(builder)) {
PsiBuilder.Marker argsMarker = builder.mark();
argsMarker.done(GroovyElementTypes.ARGUMENTS);
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
return pathElementParse(builder, newMarker, parser, Result.METHOD_CALL);
}
else {
return pathElementParse(builder, newMarker, parser, Result.INVOKED_EXPR);
}
}
@NotNull
private static Result parseAfterArguments(@NotNull PsiBuilder builder, @NotNull PsiBuilder.Marker marker, @NotNull GroovyParser parser) {
if (checkForLCurly(builder)) {
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
return pathElementParse(builder, marker, parser, Result.METHOD_CALL);
}
else {
PsiBuilder.Marker newMarker = marker.precede();
marker.done(GroovyElementTypes.PATH_METHOD_CALL);
return pathElementParse(builder, newMarker, parser, Result.METHOD_CALL);
}
}
private static boolean checkForLCurly(@NotNull PsiBuilder builder) {
return ParserUtils.lookAhead(builder, GroovyTokenTypes.mLCURLY) || ParserUtils.lookAhead(builder, GroovyTokenTypes.mNLS,
GroovyTokenTypes.mLCURLY);
}
private static boolean checkForLParenth(@NotNull PsiBuilder builder) {
return builder.getTokenType() == GroovyTokenTypes.mLPAREN;
}
public static boolean checkForArrayAccess(@NotNull PsiBuilder builder) {
return builder.getTokenType() == GroovyTokenTypes.mLBRACK &&
!ParserUtils.lookAhead(builder, GroovyTokenTypes.mLBRACK, GroovyTokenTypes.mCOLON) &&
!ParserUtils.lookAhead(builder, GroovyTokenTypes.mLBRACK, GroovyTokenTypes.mNLS, GroovyTokenTypes.mCOLON);
}
/**
* Property selector parsing
*
* @param builder
* @return
*/
@NotNull
public static GroovyElementType namePartParse(@NotNull PsiBuilder builder, @NotNull GroovyParser parser) {
ParserUtils.getToken(builder, GroovyTokenTypes.mAT);
if (ParserUtils.getToken(builder, GroovyTokenTypes.mIDENT) ||
ParserUtils.getToken(builder, GroovyTokenTypes.mSTRING_LITERAL) ||
ParserUtils.getToken(builder, GroovyTokenTypes.mGSTRING_LITERAL)) {
return GroovyElementTypes.REFERENCE_EXPRESSION;
}
final IElementType tokenType = builder.getTokenType();
if (tokenType == GroovyTokenTypes.mGSTRING_BEGIN) {
final boolean result = CompoundStringExpression.parse(builder, parser, true, GroovyTokenTypes.mGSTRING_BEGIN,
GroovyTokenTypes.mGSTRING_CONTENT, GroovyTokenTypes.mGSTRING_END, null,
GroovyElementTypes.GSTRING, GroovyBundle.message("string.end.expected"));
return result ? GroovyElementTypes.PATH_PROPERTY_REFERENCE : GroovyElementTypes.REFERENCE_EXPRESSION;
}
if (tokenType == GroovyTokenTypes.mREGEX_BEGIN) {
final boolean result = CompoundStringExpression.parse(builder, parser, true,
GroovyTokenTypes.mREGEX_BEGIN, GroovyTokenTypes.mREGEX_CONTENT,
GroovyTokenTypes.mREGEX_END, GroovyTokenTypes.mREGEX_LITERAL,
GroovyElementTypes.REGEX, GroovyBundle.message("regex.end.expected"));
return result ? GroovyElementTypes.PATH_PROPERTY_REFERENCE : GroovyElementTypes.REFERENCE_EXPRESSION;
}
if (tokenType == GroovyTokenTypes.mDOLLAR_SLASH_REGEX_BEGIN) {
final boolean result = CompoundStringExpression.parse(builder, parser, true,
GroovyTokenTypes.mDOLLAR_SLASH_REGEX_BEGIN,
GroovyTokenTypes.mDOLLAR_SLASH_REGEX_CONTENT,
GroovyTokenTypes.mDOLLAR_SLASH_REGEX_END,
GroovyTokenTypes.mDOLLAR_SLASH_REGEX_LITERAL,
GroovyElementTypes.REGEX, GroovyBundle.message("dollar.slash.end.expected"));
return result ? GroovyElementTypes.PATH_PROPERTY_REFERENCE : GroovyElementTypes.REFERENCE_EXPRESSION;
}
if (tokenType == GroovyTokenTypes.mLCURLY) {
OpenOrClosableBlock.parseOpenBlock(builder, parser);
return GroovyElementTypes.PATH_PROPERTY_REFERENCE;
}
if (tokenType == GroovyTokenTypes.mLPAREN) {
PrimaryExpression.parenthesizedExprParse(builder, parser);
return GroovyElementTypes.PATH_PROPERTY_REFERENCE;
}
if (TokenSets.KEYWORDS.contains(builder.getTokenType())) {
builder.advanceLexer();
return GroovyElementTypes.REFERENCE_EXPRESSION;
}
return GroovyElementTypes.WRONGWAY;
}
/**
* Method call parsing
*
* @param builder
* @return
*/
@NotNull
public static GroovyElementType indexPropertyArgsParse(@NotNull PsiBuilder builder, @NotNull GroovyParser parser) {
assert builder.getTokenType() == GroovyTokenTypes.mLBRACK;
PsiBuilder.Marker marker = builder.mark();
ParserUtils.getToken(builder, GroovyTokenTypes.mLBRACK);
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
ArgumentList.parseArgumentList(builder, GroovyTokenTypes.mRBRACK, parser);
ParserUtils.getToken(builder, GroovyTokenTypes.mNLS);
ParserUtils.getToken(builder, GroovyTokenTypes.mRBRACK, GroovyBundle.message("rbrack.expected"));
marker.done(GroovyElementTypes.ARGUMENTS);
return GroovyElementTypes.PATH_INDEX_PROPERTY;
}
/**
* Appended all argument parsing
*
* @param builder
* @return
*/
@NotNull
private static IElementType appendedBlockParse(@NotNull PsiBuilder builder, @NotNull GroovyParser parser) {
return OpenOrClosableBlock.parseClosableBlock(builder, parser);
}
/**
* Checks for path element start
*
* @param builder
* @return
*/
private static boolean isPathElementStart(@NotNull PsiBuilder builder) {
return (PATH_ELEMENT_START.contains(builder.getTokenType()) ||
ParserUtils.lookAhead(builder, GroovyTokenTypes.mNLS, GroovyTokenTypes.mDOT) ||
ParserUtils.lookAhead(builder, GroovyTokenTypes.mNLS, GroovyTokenTypes.mLCURLY));
}
}