/*
* Copyright (C) 2010 The Project Lombok Authors.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package lombok.ast.syntaxChecks;
import static lombok.ast.syntaxChecks.MessageKey.*;
import static lombok.ast.Message.*;
import lombok.ast.AlternateConstructorInvocation;
import lombok.ast.Block;
import lombok.ast.ConstructorDeclaration;
import lombok.ast.InstanceInitializer;
import lombok.ast.MethodDeclaration;
import lombok.ast.Modifiers;
import lombok.ast.Node;
import lombok.ast.Return;
import lombok.ast.Statement;
import lombok.ast.StaticInitializer;
import lombok.ast.SuperConstructorInvocation;
import lombok.ast.Throw;
import lombok.ast.TypeDeclaration;
import lombok.ast.VariableDefinition;
import lombok.ast.VariableDefinitionEntry;
import lombok.ast.template.SyntaxCheck;
@SyntaxCheck
public class StructuralChecks {
public void checkAbstractMembersOnlyInAbstractTypes(MethodDeclaration md) {
Modifiers modifiers = md.astModifiers();
if (modifiers == null) return;
if (!modifiers.isAbstract()) return;
TypeDeclaration parent = md.upUpToTypeDeclaration();
if (parent != null) {
Modifiers modifiersOfParent = parent.astModifiers();
if (modifiersOfParent != null && modifiersOfParent.isAbstract()) return;
md.addMessage(error(MODIFIERS_ABSTRACT_NOT_ALLOWED, "Abstract methods are only allowed in interfaces and abstract classes"));
}
}
public void initializersMustCompleteNormallyStatic(StaticInitializer node) {
initializersMustCompleteNormally(node.rawBody());
}
public void initializersMustCompleteNormallyInstance(InstanceInitializer node) {
initializersMustCompleteNormally(node.rawBody());
}
private void initializersMustCompleteNormally(Node rawBlock) {
if (!(rawBlock instanceof Block)) return;
for (Node s : ((Block)rawBlock).rawContents()) {
if (s instanceof Throw) s.addMessage(error(INITIALIZERS_INITIALIZER_MUST_COMPLETE_NORMALLY, "Initializers may not contain throws statements."));
if (s instanceof Return) s.addMessage(error(INITIALIZERS_INITIALIZER_MUST_COMPLETE_NORMALLY, "Initializers may not contain return statements."));
}
}
public void superConstructorInvocationMustBeFirst(SuperConstructorInvocation node) {
constructorInvocationMustBeFirst(node, "super");
}
public void alternateConstructorInvocationMustBeFirst(AlternateConstructorInvocation node) {
constructorInvocationMustBeFirst(node, "this");
}
private void constructorInvocationMustBeFirst(Statement node, String desc) {
if (node.getParent() == null) return;
Block b = node.upToBlock();
if (b == null || b.upToConstructorDeclaration() == null || b.astContents().first() != node) {
node.addMessage(error(CONSTRUCTOR_INVOCATION_NOT_LEGAL_HERE, "Calling " + desc + " must be the first statement in a constructor."));
return;
}
}
public void varDefOfZero(VariableDefinition node) {
if (node.astVariables().isEmpty()) {
node.addMessage(error(VARIABLEDEFINITION_EMPTY, "Empty variable declaration."));
}
}
public void varargsOnlyLegalOnMethods(VariableDefinition node) {
if (!node.astVarargs()) return;
if (node.getParent() == null) return;
MethodDeclaration md = node.upIfParameterToMethodDeclaration();
ConstructorDeclaration cd = node.upIfParameterToConstructorDeclaration();
Node last;
if (md != null) last = md.astParameters().last();
else if (cd != null) last = cd.astParameters().last();
else last = null;
if (node != last) {
node.addMessage(error(VARIABLEDEFINITION_VARARGS_NOT_LEGAL_HERE, "Varargs are only legal on the last parameter of a constructor or method."));
}
}
public void varargsAndExtendedDimsDontMix(VariableDefinitionEntry node) {
VariableDefinition vd = node.upToVariableDefinition();
if (vd == null) return;
if (node.astArrayDimensions() > 0 && vd.astVarargs()) {
node.addMessage(error(VARIABLEDEFINITIONENTRY_EXTENDED_DIMENSIONS_NOT_LEGAL, "Extended dimensions are not legal on a varargs declaration."));
}
}
public void checkMethodParamsAreSimple(MethodDeclaration md) {
for (Node param : md.rawParameters()) {
BasicChecks.checkVarDefIsSimple(param, param, "method parameters", "parameter");
}
}
public void checkConstructorParamsAreSimple(ConstructorDeclaration cd) {
for (Node param : cd.rawParameters()) {
BasicChecks.checkVarDefIsSimple(param, param, "constructor parameters", "parameter");
}
}
}