org.jetbrains.plugins.groovy.lang.parser.parsing.statements.declaration.Declaration 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.declaration;
import com.intellij.lang.PsiBuilder;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.tree.IElementType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.GroovyBundle;
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.auxiliary.modifiers.Modifiers;
import org.jetbrains.plugins.groovy.lang.parser.parsing.statements.typeDefinitions.ReferenceElement;
import org.jetbrains.plugins.groovy.lang.parser.parsing.types.TypeParameters;
import org.jetbrains.plugins.groovy.lang.parser.parsing.types.TypeSpec;
import org.jetbrains.plugins.groovy.lang.parser.parsing.util.ParserUtils;
/**
* @autor: Dmitry.Krasilschikov
* @date: 14.03.2007
*/
/*
* Declaration ::= modifiers [TypeSpec] VariableDefinitions
* | TypeSpec VariableDefinitions
*/
public class Declaration {
public static boolean parse(@NotNull PsiBuilder builder,
boolean isInClass,
boolean isInAnnotation,
@Nullable String typeDefinitionName,
@NotNull GroovyParser parser) {
PsiBuilder.Marker declMarker = builder.mark();
//allows error messages
boolean modifiersParsed = Modifiers.parse(builder, parser);
final boolean methodStart = GroovyTokenTypes.mLT == builder.getTokenType();
final IElementType type = parseAfterModifiers(builder, isInClass, isInAnnotation, typeDefinitionName, parser, modifiersParsed);
if (type == GroovyElementTypes.WRONGWAY) {
if (modifiersParsed && methodStart) {
declMarker.error(GroovyBundle.message("method.definitions.expected"));
return false;
}
declMarker.rollbackTo();
if (modifiersParsed) {
builder.error(GroovyBundle.message("variable.definitions.expected"));
}
return false;
}
if (type != null) {
declMarker.done(type);
} else {
declMarker.drop();
}
return true;
}
@Nullable
public static IElementType parseAfterModifiers(@NotNull PsiBuilder builder,
boolean isInClass,
boolean isInAnnotation,
@Nullable String typeDefinitionName,
@NotNull GroovyParser parser,
boolean modifiersParsed) {
boolean expressionPossible = !isInAnnotation && !isInClass;
if (modifiersParsed && builder.getTokenType() == GroovyTokenTypes.mLT) {
return parseDeclarationWithGenerics(builder, isInClass, isInAnnotation, typeDefinitionName, parser, modifiersParsed, expressionPossible);
}
else if (modifiersParsed) {
return parseDeclarationWithoutGenerics(builder, isInClass, isInAnnotation, typeDefinitionName, parser, modifiersParsed, expressionPossible);
}
else if (typeDefinitionName != null && ParserUtils.lookAhead(builder, GroovyTokenTypes.mIDENT, GroovyTokenTypes.mLPAREN) && typeDefinitionName.equals(builder.getTokenText())) {
//parse constructor
return VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName, modifiersParsed, false, parser);
}
else {
return parsePossibleCallExpression(builder, isInClass, isInAnnotation, typeDefinitionName, parser, expressionPossible);
}
}
private static IElementType parsePossibleCallExpression(@NotNull PsiBuilder builder,
boolean isInClass,
boolean isInAnnotation,
@Nullable String typeDefinitionName,
@NotNull GroovyParser parser,
boolean expressionPossible) {
if (isCall(builder)) {
return GroovyElementTypes.WRONGWAY;
}
boolean typeParsed = false;
if (!ParserUtils.lookAhead(builder, GroovyTokenTypes.mIDENT, GroovyTokenTypes.mLPAREN)) {
typeParsed = TypeSpec.parse(builder, true, expressionPossible) != ReferenceElement.ReferenceElementResult.FAIL;
//type specification starts with upper case letter
if (!typeParsed) {
return GroovyElementTypes.WRONGWAY;
}
}
IElementType varDef = VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName, typeParsed, false, parser);
if (varDef != GroovyElementTypes.WRONGWAY) {
return varDef;
}
if (isInClass && typeParsed) {
return null;
}
return GroovyElementTypes.WRONGWAY;
}
private static boolean isCall(@NotNull PsiBuilder builder) {
if (builder.eof()) return false;
if (TokenSets.BUILT_IN_TYPES.contains(builder.getTokenType())) return false;
final String text = builder.getTokenText();
if (StringUtil.isEmpty(text)) return false;
assert text != null;
final char firstChar = text.charAt(0);
return (Character.isLowerCase(firstChar) || !Character.isLetter(firstChar)) &&
(ParserUtils.lookAhead(builder, GroovyTokenTypes.mIDENT, GroovyTokenTypes.mIDENT) || ParserUtils.lookAhead(builder,
GroovyTokenTypes.mIDENT,
GroovyTokenTypes.mLPAREN));
}
private static IElementType parseDeclarationWithoutGenerics(@NotNull PsiBuilder builder,
boolean isInClass,
boolean isInAnnotation,
@Nullable String typeDefinitionName,
@NotNull GroovyParser parser,
boolean modifiersParsed,
boolean expressionPossible) {
PsiBuilder.Marker checkMarker = builder.mark(); //point to begin of type or variable
ReferenceElement.ReferenceElementResult typeResult = TypeSpec.parse(builder, false, expressionPossible);
if (typeResult == ReferenceElement.ReferenceElementResult.FAIL) { //if type wasn't recognized trying parse VariableDeclaration
checkMarker.rollbackTo();
if (isInAnnotation) {
builder.error(GroovyBundle.message("type.expected"));
}
//current token isn't identifier
return VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName, modifiersParsed, true, parser);
}
else { //type was recognized, identifier here
//starts after type
IElementType varDeclarationTop = VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName,
modifiersParsed, false, parser);
if (varDeclarationTop == GroovyElementTypes.WRONGWAY) {
if (typeResult == ReferenceElement.ReferenceElementResult.REF_WITH_TYPE_PARAMS) {
checkMarker.drop();
return GroovyElementTypes.VARIABLE_DEFINITION_ERROR;
}
checkMarker.rollbackTo();
if (isInAnnotation) {
builder.error(GroovyBundle.message("type.expected"));
}
//starts before "type" identifier, here can't be tuple, because next token is identifier (we are in "type recognized" branch)
return VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName, modifiersParsed, false, parser);
}
else {
checkMarker.drop();
return varDeclarationTop;
}
}
}
private static IElementType parseDeclarationWithGenerics(@NotNull PsiBuilder builder,
boolean isInClass,
boolean isInAnnotation,
@Nullable String typeDefinitionName,
@NotNull GroovyParser parser,
boolean modifiersParsed,
boolean expressionPossible) {
final PsiBuilder.Marker start = builder.mark();
final IElementType type = tryParseWithGenerics(builder, isInClass, isInAnnotation, typeDefinitionName, parser, modifiersParsed, expressionPossible, true);
if (type == GroovyElementTypes.WRONGWAY || type == GroovyElementTypes.CONSTRUCTOR_DEFINITION || type ==
GroovyElementTypes.METHOD_DEFINITION) {
start.drop();
return type;
}
start.rollbackTo();
//try to parse variable. So mark type parameters as unexpected
return tryParseWithGenerics(builder, isInClass, isInAnnotation, typeDefinitionName, parser, modifiersParsed, expressionPossible, false);
}
private static IElementType tryParseWithGenerics(@NotNull PsiBuilder builder,
boolean isInClass,
boolean isInAnnotation,
@Nullable String typeDefinitionName,
@NotNull GroovyParser parser,
boolean modifiersParsed,
boolean expressionPossible,
boolean acceptTypeParameters) {
if (acceptTypeParameters) {
TypeParameters.parse(builder);
}
else {
final PsiBuilder.Marker error = builder.mark();
TypeParameters.parse(builder);
error.error(GroovyBundle.message("type.parameters.are.unexpected"));
}
PsiBuilder.Marker checkMarker = builder.mark(); //point to begin of type or variable
switch (TypeSpec.parse(builder, false, expressionPossible)) {
case PATH_REF:
case REF_WITH_TYPE_PARAMS:
checkMarker.drop();
break;
case FAIL:
checkMarker.rollbackTo();
break;
case IDENTIFIER:
// declaration name element can be parsed as type element
IElementType result = VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName, modifiersParsed, false, parser);
if (result == GroovyElementTypes.WRONGWAY) {
checkMarker.rollbackTo();
}
else {
checkMarker.drop();
return result;
}
}
return VariableDefinitions.parseDefinitions(builder, isInClass, isInAnnotation, typeDefinitionName, modifiersParsed, false, parser);
}
}