private void doAddConstructor(final ClassNode cNode, final ConstructorNode constructorNode) {
cNode.addConstructor(constructorNode);
// GROOVY-5814: Immutable is not compatible with @CompileStatic
Parameter argsParam = null;
for (Parameter p : constructorNode.getParameters()) {
if ("args".equals(p.getName())) {
argsParam = p;
break;
}
}
if (argsParam != null) {
final Parameter arg = argsParam;
ClassCodeVisitorSupport variableExpressionFix =
new ClassCodeVisitorSupport() {
@Override
protected SourceUnit getSourceUnit() {
return cNode.getModule().getContext();
}
@Override
public void visitVariableExpression(final VariableExpression expression) {
super.visitVariableExpression(expression);
if ("args".equals(expression.getName())) {
expression.setAccessedVariable(arg);
}
}
};
variableExpressionFix.visitConstructor(constructorNode);
}
}
public void visitConstructorCallExpression(ConstructorCallExpression call) {
isSpecialConstructorCall = call.isSpecialCall();
super.visitConstructorCallExpression(call);
isSpecialConstructorCall = false;
if (!call.isUsingAnonymousInnerClass()) return;
pushState();
InnerClassNode innerClass = (InnerClassNode) call.getType();
innerClass.setVariableScope(currentScope);
for (MethodNode method : innerClass.getMethods()) {
Parameter[] parameters = method.getParameters();
if (parameters.length == 0) parameters = null; // null means no implicit "it"
ClosureExpression cl = new ClosureExpression(parameters, method.getCode());
visitClosureExpression(cl);
}
for (FieldNode field : innerClass.getFields()) {
final Expression expression = field.getInitialExpression();
if (expression != null) {
expression.visit(this);
}
}
for (Statement statement : innerClass.getObjectInitializerStatements()) {
statement.visit(this);
}
markClosureSharedVariables();
popState();
}
public void visitClosureExpression(ClosureExpression expression) {
pushState();
expression.setVariableScope(currentScope);
if (expression.isParameterSpecified()) {
Parameter[] parameters = expression.getParameters();
for (Parameter parameter : parameters) {
parameter.setInStaticContext(currentScope.isInStaticContext());
if (parameter.hasInitialExpression()) {
parameter.getInitialExpression().visit(this);
}
declare(parameter, expression);
}
} else if (expression.getParameters() != null) {
Parameter var = new Parameter(ClassHelper.OBJECT_TYPE, "it");
var.setInStaticContext(currentScope.isInStaticContext());
currentScope.putDeclaredVariable(var);
}
super.visitClosureExpression(expression);
markClosureSharedVariables();
popState();
}
public void visitBinaryExpression(BinaryExpression expression) {
if (expression.getOperation().getType() == Types.LEFT_SQUARE_BRACKET
&& expression.getRightExpression() instanceof MapEntryExpression) {
addError(
"You tried to use a map entry for an index operation, this is not allowed. "
+ "Maybe something should be set in parentheses or a comma is missing?",
expression.getRightExpression());
}
super.visitBinaryExpression(expression);
switch (expression.getOperation().getType()) {
case Types.EQUAL: // = assignment
case Types.BITWISE_AND_EQUAL:
case Types.BITWISE_OR_EQUAL:
case Types.BITWISE_XOR_EQUAL:
case Types.PLUS_EQUAL:
case Types.MINUS_EQUAL:
case Types.MULTIPLY_EQUAL:
case Types.DIVIDE_EQUAL:
case Types.INTDIV_EQUAL:
case Types.MOD_EQUAL:
case Types.POWER_EQUAL:
case Types.LEFT_SHIFT_EQUAL:
case Types.RIGHT_SHIFT_EQUAL:
case Types.RIGHT_SHIFT_UNSIGNED_EQUAL:
checkFinalFieldAccess(expression.getLeftExpression());
break;
default:
break;
}
}
@Override
public void visitClosureExpression(final ClosureExpression expression) {
boolean old = inAssignment;
inAssignment = false;
super.visitClosureExpression(expression);
inAssignment = old;
}
@Override
public void visitPostfixExpression(final PostfixExpression expression) {
inAssignment = expression.getExpression() instanceof VariableExpression;
super.visitPostfixExpression(expression);
inAssignment = false;
checkPrePostfixOperation(expression.getExpression(), expression);
}
/**
* Adds the annotation to the internal target list if a match is found.
*
* @param node the AST node we are processing
*/
public void visitAnnotations(AnnotatedNode node) {
super.visitAnnotations(node);
for (AnnotationNode an : node.getAnnotations()) {
String name = an.getClassNode().getName();
if ((GRAB_CLASS_NAME.equals(name))
|| (allowShortGrab && GRAB_SHORT_NAME.equals(name))
|| (grabAliases.contains(name))) {
grabAnnotations.add(an);
}
if ((GRABEXCLUDE_CLASS_NAME.equals(name))
|| (allowShortGrabExcludes && GRABEXCLUDE_SHORT_NAME.equals(name))
|| (grabExcludeAliases.contains(name))) {
grabExcludeAnnotations.add(an);
}
if ((GRABCONFIG_CLASS_NAME.equals(name))
|| (allowShortGrabConfig && GRABCONFIG_SHORT_NAME.equals(name))
|| (grabConfigAliases.contains(name))) {
grabConfigAnnotations.add(an);
}
if ((GRAPES_CLASS_NAME.equals(name))
|| (allowShortGrapes && GRAPES_SHORT_NAME.equals(name))
|| (grapesAliases.contains(name))) {
grapesAnnotations.add(an);
}
if ((GRABRESOLVER_CLASS_NAME.equals(name))
|| (allowShortGrabResolver && GRABRESOLVER_SHORT_NAME.equals(name))
|| (grabResolverAliases.contains(name))) {
grabResolverAnnotations.add(an);
}
}
}
public void visitMethodCallExpression(MethodCallExpression call) {
if (call.isImplicitThis() && call.getMethod() instanceof ConstantExpression) {
ConstantExpression methodNameConstant = (ConstantExpression) call.getMethod();
Object value = methodNameConstant.getText();
if (!(value instanceof String)) {
throw new GroovyBugError(
"tried to make a method call with a non-String constant method name.");
}
String methodName = (String) value;
Variable v = checkVariableNameForDeclaration(methodName, call);
if (v != null && !(v instanceof DynamicVariable)) {
checkVariableContextAccess(v, call);
}
if (v instanceof VariableExpression || v instanceof Parameter) {
VariableExpression object = new VariableExpression(v);
object.setSourcePosition(methodNameConstant);
call.setObjectExpression(object);
ConstantExpression method = new ConstantExpression("call");
method.setSourcePosition(methodNameConstant); // important for GROOVY-4344
call.setImplicitThis(false);
call.setMethod(method);
}
}
super.visitMethodCallExpression(call);
}
public void visitCatchStatement(CatchStatement statement) {
pushState();
Parameter p = statement.getVariable();
p.setInStaticContext(currentScope.isInStaticContext());
declare(p, statement);
super.visitCatchStatement(statement);
popState();
}
@Override
public void visitMethodCallExpression(final MethodCallExpression call) {
super.visitMethodCallExpression(call);
MethodNode mn = call.getMethodTarget();
if (mn == null) {
call.setMethodTarget(doCallMethod);
}
}
/**
* Adds the annotation to the internal target list if a match is found.
*
* @param node the node to be processed
*/
public void visitAnnotations(AnnotatedNode node) {
super.visitAnnotations(node);
for (AnnotationNode annotation : node.getAnnotations()) {
if (transforms.containsKey(annotation)) {
targetNodes.add(new ASTNode[] {annotation, node});
}
}
}
public void visitField(FieldNode node) {
if (currentClass.getDeclaredField(node.getName()) != node) {
addError("The " + getDescription(node) + " is declared multiple times.", node);
}
checkInterfaceFieldModifiers(node);
checkGenericsUsage(node, node.getType());
super.visitField(node);
}
public void visitForLoop(ForStatement forLoop) {
pushState();
forLoop.setVariableScope(currentScope);
Parameter p = forLoop.getVariable();
p.setInStaticContext(currentScope.isInStaticContext());
if (p != ForStatement.FOR_LOOP_DUMMY) declare(p, forLoop);
super.visitForLoop(forLoop);
popState();
}
@Override
public void visitPackage(final PackageNode node) {
if (node != null) {
pushContext(node);
}
super.visitPackage(node);
if (node != null) {
popContext();
}
}
public void visitMethod(MethodNode node) {
inConstructor = false;
inStaticConstructor = node.isStaticConstructor();
checkAbstractDeclaration(node);
checkRepetitiveMethod(node);
checkOverloadingPrivateAndPublic(node);
checkMethodModifiers(node);
checkGenericsUsage(node, node.getParameters());
checkGenericsUsage(node, node.getReturnType());
super.visitMethod(node);
}
public void visitMethodCallExpression(MethodCallExpression mce) {
super.visitMethodCallExpression(mce);
Expression aexp = mce.getArguments();
if (aexp instanceof TupleExpression) {
TupleExpression arguments = (TupleExpression) aexp;
for (Expression e : arguments.getExpressions()) {
checkForInvalidDeclaration(e);
}
} else {
checkForInvalidDeclaration(aexp);
}
}
@Override
public void visitMethodCallExpression(MethodCallExpression call) {
String name =
call.getMethodAsString(); // Could be null (for 'funny' calls where target name is dynamic)
SearchingCodeVisitor.MethodCallAction action = getMethodCallAction(name);
if (action != null) {
Assert.isLegal(action.methodName.equals(name));
if (!isVisited(call)) {
action.doit(this, call);
}
}
super.visitMethodCallExpression(call);
}
@Override
public void visitVariableExpression(final VariableExpression expression) {
super.visitVariableExpression(expression);
if (inAssignment) {
Map<Variable, VariableState> state = getState();
Variable key = expression.getAccessedVariable();
VariableState variableState = state.get(key);
if (variableState == VariableState.is_uninitialized) {
variableState = VariableState.is_var;
state.put(key, variableState);
}
}
}
public void visitClass(ClassNode node) {
// AIC are already done, doing them here again will lead
// to wrong scopes
if (node instanceof InnerClassNode) {
InnerClassNode in = (InnerClassNode) node;
if (in.isAnonymous()) return;
}
pushState();
prepareVisit(node);
super.visitClass(node);
popState();
}
@Override
public void visitDeclarationExpression(DeclarationExpression expression) {
super.visitDeclarationExpression(expression);
if (expression.isMultipleAssignmentDeclaration()) return;
checkInvalidDeclarationModifier(expression, ACC_ABSTRACT, "abstract");
checkInvalidDeclarationModifier(expression, ACC_NATIVE, "native");
checkInvalidDeclarationModifier(expression, ACC_PRIVATE, "private");
checkInvalidDeclarationModifier(expression, ACC_PROTECTED, "protected");
checkInvalidDeclarationModifier(expression, ACC_PUBLIC, "public");
checkInvalidDeclarationModifier(expression, ACC_STATIC, "static");
checkInvalidDeclarationModifier(expression, ACC_STRICT, "strictfp");
checkInvalidDeclarationModifier(expression, ACC_SYNCHRONIZED, "synchronized");
checkInvalidDeclarationModifier(expression, ACC_TRANSIENT, "transient");
checkInvalidDeclarationModifier(expression, ACC_VOLATILE, "volatile");
}
@Override
public void visitBlockStatement(final BlockStatement block) {
Set<VariableExpression> old = declaredFinalVariables;
declaredFinalVariables = new HashSet<VariableExpression>();
super.visitBlockStatement(block);
if (callback != null) {
Map<Variable, VariableState> state = getState();
for (VariableExpression declaredFinalVariable : declaredFinalVariables) {
VariableState variableState = state.get(declaredFinalVariable.getAccessedVariable());
if (variableState == null || variableState != VariableState.is_final) {
callback.variableNotAlwaysInitialized(declaredFinalVariable);
}
}
}
declaredFinalVariables = old;
}
@Override
public void visitClass(ClassNode node) {
boolean isToplevel = false;
if (currentTopLevelClass == null) {
// entering top level class
currentTopLevelClass = node;
isToplevel = true;
}
try {
super.visitClass(node);
} finally {
if (isToplevel) {
// Exiting top level class
currentTopLevelClass = null;
}
}
}
public void visitClass(ClassNode node) {
ClassNode oldClass = currentClass;
currentClass = node;
checkImplementsAndExtends(node);
if (source != null && !source.getErrorCollector().hasErrors()) {
checkClassForIncorrectModifiers(node);
checkInterfaceMethodVisibility(node);
checkClassForOverwritingFinal(node);
checkMethodsForIncorrectModifiers(node);
checkMethodsForWeakerAccess(node);
checkMethodsForOverridingFinal(node);
checkNoAbstractMethodsNonabstractClass(node);
checkGenericsUsage(node, node.getUnresolvedInterfaces());
checkGenericsUsage(node, node.getUnresolvedSuperClass());
}
super.visitClass(node);
currentClass = oldClass;
}
@Override
public void visitBytecodeExpression(BytecodeExpression expression) {
// LOG.debug "Transforming expression '${expression}':"
if (expression.getLineNumber() >= 0 && expression.getLineNumber() < lineNumbers.length) {
// LOG.debug " start from ${expression.lineNumber} to ${lineNumbers[expression.lineNumber
// - 1]}"
expression.setLineNumber(lineNumbers[expression.getLineNumber() - 1]);
}
if (expression.getLastLineNumber() > 0
&& expression.getLastLineNumber() < lineNumbers.length) {
// LOG.debug " end from ${expression.lastLineNumber} to
// ${lineNumbers[expression.lastLineNumber - 1]}"
expression.setLastLineNumber(lineNumbers[expression.getLastLineNumber() - 1]);
}
super.visitBytecodeExpression(expression);
}
/**
* If the annotation is annotated with {@link GroovyASTTransformation} the annotation is added to
* <code>stageVisitors</code> at the appropriate processor visitor.
*
* @param node the node to process
*/
public void visitAnnotations(AnnotatedNode node) {
super.visitAnnotations(node);
List<AnnotationNode> collected = new ArrayList<AnnotationNode>();
for (Iterator<AnnotationNode> it = node.getAnnotations().iterator(); it.hasNext(); ) {
AnnotationNode annotation = it.next();
if (addCollectedAnnotations(collected, annotation, node)) it.remove();
}
node.getAnnotations().addAll(collected);
for (AnnotationNode annotation : node.getAnnotations()) {
// GRECLIPSE: start: under eclipse we may be asking a node that has no backing class
/*{
Annotation transformClassAnnotation = getTransformClassAnnotation(annotation.getClassNode());
if (transformClassAnnotation == null) {
// skip if there is no such annotation
continue;
}
addTransformsToClassNode(annotation, transformClassAnnotation);
}*/
// newcode:
if (!this.allowTransforms) {
if (!isAllowed(annotation.getClassNode().getName())) {
continue;
}
}
// GRECLIPSE end
String[] transformClassNames = getTransformClassNames(annotation.getClassNode());
Class[] transformClasses = getTransformClasses(annotation.getClassNode());
if (transformClassNames == null && transformClasses == null) {
continue;
}
if (transformClassNames == null) {
transformClassNames = NONE;
}
if (transformClasses == null) {
transformClasses = NO_CLASSES;
}
addTransformsToClassNode(annotation, transformClassNames, transformClasses);
// end
}
}
@Override
public void visitBinaryExpression(BinaryExpression be) {
super.visitBinaryExpression(be);
switch (be.getOperation().getType()) {
case Types.EQUAL: // = assignment
case Types.BITWISE_AND_EQUAL:
case Types.BITWISE_OR_EQUAL:
case Types.BITWISE_XOR_EQUAL:
case Types.PLUS_EQUAL:
case Types.MINUS_EQUAL:
case Types.MULTIPLY_EQUAL:
case Types.DIVIDE_EQUAL:
case Types.INTDIV_EQUAL:
case Types.MOD_EQUAL:
case Types.POWER_EQUAL:
case Types.LEFT_SHIFT_EQUAL:
case Types.RIGHT_SHIFT_EQUAL:
case Types.RIGHT_SHIFT_UNSIGNED_EQUAL:
checkFinalFieldAccess(be.getLeftExpression());
break;
default:
break;
}
}
@Override
protected void visitEmptyStatement(final EmptyStatement statement) {
pushContext(statement);
super.visitEmptyStatement(statement);
popContext();
}
@Override
public void visitWhileLoop(final WhileStatement loop) {
pushContext(loop);
super.visitWhileLoop(loop);
popContext();
}
@Override
public void visitTryCatchFinally(final TryCatchStatement statement) {
pushContext(statement);
super.visitTryCatchFinally(statement);
popContext();
}
@Override
public void visitThrowStatement(final ThrowStatement statement) {
pushContext(statement);
super.visitThrowStatement(statement);
popContext();
}