public void visit(ASTNode[] nodes, SourceUnit source) {
if (nodes.length != 2
|| !(nodes[0] instanceof AnnotationNode)
|| !(nodes[1] instanceof AnnotatedNode)) {
throw new RuntimeException(
"Internal error: expecting [AnnotationNode, AnnotatedNode] but got: "
+ Arrays.asList(nodes));
}
AnnotationNode annotationNode = (AnnotationNode) nodes[0];
ASTNode node = nodes[1];
if (!(node instanceof MethodNode)) {
addError("@NotYetImplemented must only be applied on test methods!", node);
return;
}
MethodNode methodNode = (MethodNode) node;
ArrayList<Statement> statements = new ArrayList<Statement>();
Statement statement = methodNode.getCode();
if (statement instanceof BlockStatement) {
statements.addAll(((BlockStatement) statement).getStatements());
}
if (statements.size() == 0) return;
BlockStatement rewrittenMethodCode = new BlockStatement();
rewrittenMethodCode.addStatement(
tryCatchAssertionFailedError(annotationNode, methodNode, statements));
rewrittenMethodCode.addStatement(throwAssertionFailedError(annotationNode));
methodNode.setCode(rewrittenMethodCode);
}
private Statement getMethodBody(MethodNode methodNode) {
Statement code = methodNode.getCode();
if (!(code instanceof BlockStatement)) {
BlockStatement body = new BlockStatement();
body.addStatement(code);
code = body;
}
return code;
}
@Override
public void visit(BlockStatement statement) {
List<Statement> statements = processSequence(statement.getBody());
eliminateRedundantBreaks(statements, statement);
BlockCountVisitor usageCounter = new BlockCountVisitor(statement);
usageCounter.visit(statements);
if (usageCounter.getCount() == 0) {
SequentialStatement result = new SequentialStatement();
result.getSequence().addAll(statements);
resultStmt = result;
} else {
statement.getBody().clear();
statement.getBody().addAll(statements);
resultStmt = statement;
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
if (!super.equals(o)) {
return false;
}
FunctionExpression that = (FunctionExpression) o;
if (body != null ? !body.equals(that.body) : that.body != null) {
return false;
}
if (function != null ? !function.equals(that.function) : that.function != null) {
return false;
}
if (!parameterList.equals(that.parameterList)) {
return false;
}
return true;
}
private void validateFields(BlockStatement block) {
Validation.Option mode =
getEnumMemberValue(
getAnnotation(annotatedClass, VALIDATION_ANNOTATION),
"option",
Validation.Option.class,
Validation.Option.IGNORE_UNMARKED);
for (FieldNode fieldNode : annotatedClass.getFields()) {
if (shouldFieldBeIgnoredForValidation(fieldNode)) continue;
ClosureExpression validationClosure =
createGroovyTruthClosureExpression(block.getVariableScope());
String message = null;
AnnotationNode validateAnnotation = getAnnotation(fieldNode, VALIDATE_ANNOTATION);
if (validateAnnotation != null) {
message =
getMemberStringValue(
validateAnnotation, "message", "'" + fieldNode.getName() + "' must be set!");
Expression member = validateAnnotation.getMember("value");
if (member instanceof ClassExpression) {
ClassNode memberType = member.getType();
if (memberType.equals(ClassHelper.make(Validate.Ignore.class))) continue;
else if (!memberType.equals(ClassHelper.make(Validate.GroovyTruth.class))) {
addError(
"value of Validate must be either Validate.GroovyTruth, Validate.Ignore or a closure.",
fieldNode);
}
} else if (member instanceof ClosureExpression) {
validationClosure = (ClosureExpression) member;
}
}
if (validateAnnotation != null || mode == Validation.Option.VALIDATE_UNMARKED) {
block.addStatement(
new AssertStatement(
new BooleanExpression(
callX(validationClosure, "call", args(varX(fieldNode.getName())))),
message == null ? ConstantExpression.NULL : new ConstantExpression(message)));
}
}
}
protected void addMockCollaborator(
String mockType, ClassExpression targetClass, BlockStatement methodBody) {
ArgumentListExpression args = new ArgumentListExpression();
args.addExpression(targetClass);
methodBody
.getStatements()
.add(
0,
new ExpressionStatement(
new MethodCallExpression(THIS_EXPRESSION, "mock" + mockType, args)));
}
private IfStatement getAutowiringIfStatement(
ClassExpression targetClass,
VariableExpression fieldExpression,
BinaryExpression testTargetAssignment) {
VariableExpression appCtxVar = new VariableExpression("applicationContext");
BooleanExpression applicationContextCheck =
new BooleanExpression(
new BinaryExpression(
new BinaryExpression(
fieldExpression,
GrailsASTUtils.EQUALS_OPERATOR,
GrailsASTUtils.NULL_EXPRESSION),
Token.newSymbol("&&", 0, 0),
new BinaryExpression(
appCtxVar,
GrailsASTUtils.NOT_EQUALS_OPERATOR,
GrailsASTUtils.NULL_EXPRESSION)));
BlockStatement performAutowireBlock = new BlockStatement();
ArgumentListExpression arguments = new ArgumentListExpression();
arguments.addExpression(fieldExpression);
arguments.addExpression(new ConstantExpression(1));
arguments.addExpression(new ConstantExpression(false));
BlockStatement assignFromApplicationContext = new BlockStatement();
ArgumentListExpression argWithClassName = new ArgumentListExpression();
MethodCallExpression getClassNameMethodCall =
new MethodCallExpression(targetClass, "getName", new ArgumentListExpression());
argWithClassName.addExpression(getClassNameMethodCall);
assignFromApplicationContext.addStatement(
new ExpressionStatement(
new BinaryExpression(
fieldExpression,
ASSIGN,
new MethodCallExpression(appCtxVar, "getBean", argWithClassName))));
BlockStatement elseBlock = new BlockStatement();
elseBlock.addStatement(new ExpressionStatement(testTargetAssignment));
performAutowireBlock.addStatement(
new IfStatement(
new BooleanExpression(
new MethodCallExpression(appCtxVar, "containsBean", argWithClassName)),
assignFromApplicationContext,
elseBlock));
performAutowireBlock.addStatement(
new ExpressionStatement(
new MethodCallExpression(
new PropertyExpression(appCtxVar, "autowireCapableBeanFactory"),
"autowireBeanProperties",
arguments)));
return new IfStatement(applicationContextCheck, performAutowireBlock, new BlockStatement());
}
@Override
public int hashCode() {
int result = hash;
if (result == 0) {
result = super.hashCode();
result = 31 * result + (function != null ? function.hashCode() : 0);
result = 31 * result + (body != null ? body.hashCode() : 0);
result = 31 * result + parameterList.hashCode();
if (result == 0) {
result = 1;
}
hash = result;
}
return result;
}
public static IElementType parse(PsiBuilder builder, GoParser parser) {
if (!ParserUtils.lookAhead(builder, kIF)) return null;
PsiBuilder.Marker marker = builder.mark();
ParserUtils.getToken(builder, kIF);
PsiBuilder.Marker mark = builder.mark();
boolean allowComposite = parser.resetFlag(AllowCompositeLiteral, false);
IElementType statementType = parser.parseStatementSimple(builder);
if (statementType == EXPRESSION_STATEMENT && ParserUtils.lookAhead(builder, pLCURLY)) {
mark.rollbackTo();
} else {
mark.drop();
ParserUtils.endStatement(builder);
}
parser.parseExpression(builder);
parser.resetFlag(AllowCompositeLiteral, allowComposite);
parser.parseBody(builder);
if (ParserUtils.lookAhead(builder, kELSE)) {
if (builder.getTokenType() == kELSE) {
ParserUtils.getToken(builder, kELSE);
if (ParserUtils.lookAhead(builder, kIF)) IfStatement.parse(builder, parser);
else if (ParserUtils.lookAhead(builder, pLCURLY)) BlockStatement.parse(builder, parser);
else {
builder.error(GoBundle.message("error.block.of.if.statement.expected"));
}
}
}
marker.done(IF_STATEMENT);
return IF_STATEMENT;
}
protected MethodNode addClassUnderTestMethod(
ClassNode classNode, ClassExpression targetClass, String type) {
String methodName = "setup" + type + "UnderTest";
String fieldName = GrailsNameUtils.getPropertyName(type);
String getterName = GrailsNameUtils.getGetterName(fieldName);
fieldName = '$' + fieldName;
if (classNode.getField(fieldName) == null) {
classNode.addField(fieldName, Modifier.PRIVATE, targetClass.getType(), null);
}
MethodNode methodNode =
classNode.getMethod(methodName, GrailsArtefactClassInjector.ZERO_PARAMETERS);
VariableExpression fieldExpression = new VariableExpression(fieldName);
if (methodNode == null) {
BlockStatement setupMethodBody = new BlockStatement();
addMockCollaborator(type, targetClass, setupMethodBody);
methodNode =
new MethodNode(
methodName,
Modifier.PUBLIC,
ClassHelper.VOID_TYPE,
GrailsArtefactClassInjector.ZERO_PARAMETERS,
null,
setupMethodBody);
methodNode.addAnnotation(BEFORE_ANNOTATION);
methodNode.addAnnotation(MIXIN_METHOD_ANNOTATION);
classNode.addMethod(methodNode);
}
MethodNode getter =
classNode.getMethod(getterName, GrailsArtefactClassInjector.ZERO_PARAMETERS);
if (getter == null) {
BlockStatement getterBody = new BlockStatement();
getter =
new MethodNode(
getterName,
Modifier.PUBLIC,
targetClass.getType().getPlainNodeReference(),
GrailsArtefactClassInjector.ZERO_PARAMETERS,
null,
getterBody);
BinaryExpression testTargetAssignment =
new BinaryExpression(
fieldExpression,
ASSIGN,
new ConstructorCallExpression(
targetClass.getType(), GrailsArtefactClassInjector.ZERO_ARGS));
IfStatement autowiringIfStatement =
getAutowiringIfStatement(targetClass, fieldExpression, testTargetAssignment);
getterBody.addStatement(autowiringIfStatement);
getterBody.addStatement(new ReturnStatement(fieldExpression));
classNode.addMethod(getter);
}
return methodNode;
}
private void eliminateRedundantBreaks(List<Statement> statements, IdentifiedStatement exit) {
if (statements.isEmpty()) {
return;
}
Statement last = statements.get(statements.size() - 1);
if (last instanceof BreakStatement && exit != null) {
IdentifiedStatement target = ((BreakStatement) last).getTarget();
if (exit == target) {
statements.remove(statements.size() - 1);
}
}
if (statements.isEmpty()) {
return;
}
for (int i = 0; i < statements.size(); ++i) {
Statement stmt = statements.get(i);
if (stmt instanceof ConditionalStatement) {
ConditionalStatement cond = (ConditionalStatement) stmt;
check_conditional:
{
last =
cond.getConsequent().isEmpty()
? null
: cond.getConsequent().get(cond.getConsequent().size() - 1);
if (last instanceof BreakStatement) {
BreakStatement breakStmt = (BreakStatement) last;
if (exit != null && exit == breakStmt.getTarget()) {
cond.getConsequent().remove(cond.getConsequent().size() - 1);
List<Statement> remaining = statements.subList(i + 1, statements.size());
cond.getAlternative().addAll(remaining);
remaining.clear();
break check_conditional;
}
}
last =
cond.getAlternative().isEmpty()
? null
: cond.getAlternative().get(cond.getAlternative().size() - 1);
if (last instanceof BreakStatement) {
BreakStatement breakStmt = (BreakStatement) last;
if (exit != null && exit == breakStmt.getTarget()) {
cond.getAlternative().remove(cond.getAlternative().size() - 1);
List<Statement> remaining = statements.subList(i + 1, statements.size());
cond.getConsequent().addAll(remaining);
remaining.clear();
}
}
}
if (i == statements.size() - 1) {
eliminateRedundantBreaks(cond.getConsequent(), exit);
eliminateRedundantBreaks(cond.getAlternative(), exit);
}
normalizeConditional(cond);
if (cond.getConsequent().size() == 1
&& cond.getConsequent().get(0) instanceof ConditionalStatement) {
ConditionalStatement innerCond = (ConditionalStatement) cond.getConsequent().get(0);
if (innerCond.getAlternative().isEmpty()) {
if (cond.getAlternative().isEmpty()) {
cond.getConsequent().clear();
cond.getConsequent().addAll(innerCond.getConsequent());
cond.setCondition(
Expr.binary(
BinaryOperation.AND,
cond.getCondition(),
innerCond.getCondition(),
cond.getCondition().getLocation()));
--i;
} else if (cond.getAlternative().size() != 1
|| !(cond.getAlternative().get(0) instanceof ConditionalStatement)) {
cond.setCondition(ExprOptimizer.invert(cond.getCondition()));
cond.getConsequent().clear();
cond.getConsequent().addAll(cond.getAlternative());
cond.getAlternative().clear();
cond.getAlternative().add(innerCond);
--i;
}
}
}
} else if (stmt instanceof BlockStatement) {
BlockStatement nestedBlock = (BlockStatement) stmt;
eliminateRedundantBreaks(nestedBlock.getBody(), nestedBlock);
} else if (stmt instanceof WhileStatement) {
WhileStatement whileStmt = (WhileStatement) stmt;
eliminateRedundantBreaks(whileStmt.getBody(), null);
} else if (stmt instanceof SwitchStatement) {
SwitchStatement switchStmt = (SwitchStatement) stmt;
for (SwitchClause clause : switchStmt.getClauses()) {
eliminateRedundantBreaks(clause.getBody(), null);
}
eliminateRedundantBreaks(switchStmt.getDefaultClause(), null);
}
}
}
public void visitBlockStatement(BlockStatement block) {
for (Statement statement : block.getStatements()) {
if (statement != null) // GRECLIPSE
statement.visit(this);
}
}
private void validateCustomMethods(BlockStatement block) {
if (!annotatedClass.hasMethod("doValidate", Parameter.EMPTY_ARRAY)) return;
block.addStatement(stmt(callX(varX("this"), "doValidate")));
}
@Override
void accept(ExpressionWriter writer, int lprec, int rprec) {
// "new Function1() {
// public Result apply(T1 p1, ...) {
// <body>
// }
// // bridge method
// public Object apply(Object p1, ...) {
// return apply((T1) p1, ...);
// }
// }
//
// if any arguments are primitive there is an extra bridge method:
//
// new Function1() {
// public double apply(double p1, int p2) {
// <body>
// }
// // box bridge method
// public Double apply(Double p1, Integer p2) {
// return apply(p1.doubleValue(), p2.intValue());
// }
// // bridge method
// public Object apply(Object p1, Object p2) {
// return apply((Double) p1, (Integer) p2);
// }
List<String> params = new ArrayList<String>();
List<String> bridgeParams = new ArrayList<String>();
List<String> bridgeArgs = new ArrayList<String>();
List<String> boxBridgeParams = new ArrayList<String>();
List<String> boxBridgeArgs = new ArrayList<String>();
for (ParameterExpression parameterExpression : parameterList) {
final Type parameterType = parameterExpression.getType();
final Type parameterBoxType = Types.box(parameterType);
final String parameterBoxTypeName = Types.className(parameterBoxType);
params.add(parameterExpression.declString());
bridgeParams.add(parameterExpression.declString(Object.class));
bridgeArgs.add("(" + parameterBoxTypeName + ") " + parameterExpression.name);
boxBridgeParams.add(parameterExpression.declString(parameterBoxType));
boxBridgeArgs.add(
parameterExpression.name
+ (Primitive.is(parameterType)
? "." + Primitive.of(parameterType).primitiveName + "Value()"
: ""));
}
Type bridgeResultType = Functions.FUNCTION_RESULT_TYPES.get(this.type);
if (bridgeResultType == null) {
bridgeResultType = body.getType();
}
Type resultType2 = bridgeResultType;
if (bridgeResultType == Object.class
&& !params.equals(bridgeParams)
&& !(body.getType() instanceof TypeVariable)) {
resultType2 = body.getType();
}
String methodName = getAbstractMethodName();
writer
.append("new ")
.append(type)
.append("()")
.begin(" {\n")
.append("public ")
.append(Types.className(resultType2))
.list(" " + methodName + "(", ", ", ") ", params)
.append(Blocks.toFunctionBlock(body));
// Generate an intermediate bridge method if at least one parameter is
// primitive.
if (!boxBridgeParams.equals(params)) {
writer
.append("public ")
.append(Types.boxClassName(bridgeResultType))
.list(" " + methodName + "(", ", ", ") ", boxBridgeParams)
.begin("{\n")
.list("return " + methodName + "(\n", ",\n", ");\n", boxBridgeArgs)
.end("}\n");
}
// Generate a bridge method. Argument types are looser (as if every
// type parameter is set to 'Object').
//
// Skip the bridge method if there are no arguments. It would have the
// same overload as the regular method.
if (!bridgeParams.equals(params)) {
writer
.append("public ")
.append(Types.boxClassName(bridgeResultType))
.list(" " + methodName + "(", ", ", ") ", bridgeParams)
.begin("{\n")
.list("return " + methodName + "(\n", ",\n", ");\n", bridgeArgs)
.end("}\n");
}
writer.end("}\n");
}
public void visitBlockStatement(BlockStatement block) {
for (Statement statement : block.getStatements()) {
statement.visit(this);
}
}
