private void changeBaseScriptTypeFromDeclaration(
final DeclarationExpression de, final AnnotationNode node) {
if (de.isMultipleAssignmentDeclaration()) {
addError(
"Annotation " + MY_TYPE_NAME + " not supported with multiple assignment notation.", de);
return;
}
if (!(de.getRightExpression() instanceof EmptyExpression)) {
addError("Annotation " + MY_TYPE_NAME + " not supported with variable assignment.", de);
return;
}
Expression value = node.getMember("value");
if (value != null) {
addError(
"Annotation " + MY_TYPE_NAME + " cannot have member 'value' if used on a declaration.",
value);
return;
}
ClassNode cNode = de.getDeclaringClass();
ClassNode baseScriptType = de.getVariableExpression().getType().getPlainNodeReference();
de.setRightExpression(new VariableExpression("this"));
changeBaseScriptType(de, cNode, baseScriptType);
}
/**
* Wrap the given expression with a logging method call. Some kinds of expressions don't like
* being wrapped in a simple fashion and so we have to handle them specially. The
* ExpressionTransformer doesn't have methods for each type so we check for each one here.
*
* <p>TODO: There are potentially other expressions which need special handling (like indexing and
* variables). This code may be working because those types have their parent being wrapped and we
* don't transform their children.
*
* @param lineNumber line number to report for this value
* @param expression the expression whose value we want to report
* @return an expression that computes the value and also reports it somewheres
*/
private Expression loggingExpression(Integer lineNumber, Expression expression) {
if (expression instanceof DeclarationExpression) {
DeclarationExpression declarationExpression = (DeclarationExpression) expression;
return new DeclarationExpression(
declarationExpression.getLeftExpression(),
declarationExpression.getOperation(),
loggingExpression(lineNumber, declarationExpression.getRightExpression()));
}
if (expression instanceof BooleanExpression) {
BooleanExpression booleanExpression = (BooleanExpression) expression;
return new BooleanExpression(
new MethodCallExpression(
new VariableExpression("this"),
"_log",
new ArgumentListExpression(
new ConstantExpression(lineNumber), booleanExpression.getExpression())));
}
return new MethodCallExpression(
new VariableExpression("this"),
"_log",
new ArgumentListExpression(new ConstantExpression(lineNumber), expression));
}
public void visitDeclarationExpression(DeclarationExpression expression) {
// visit right side first to avoid the usage of a
// variable before its declaration
expression.getRightExpression().visit(this);
if (expression.isMultipleAssignmentDeclaration()) {
TupleExpression list = expression.getTupleExpression();
for (Expression e : list.getExpressions()) {
declare((VariableExpression) e);
}
} else {
declare(expression.getVariableExpression());
}
}
private void setScriptURIOnDeclaration(
final DeclarationExpression de, final AnnotationNode node) {
if (de.isMultipleAssignmentDeclaration()) {
addError(
"Annotation " + MY_TYPE_NAME + " not supported with multiple assignment notation.", de);
return;
}
if (!(de.getRightExpression() instanceof EmptyExpression)) {
addError("Annotation " + MY_TYPE_NAME + " not supported with variable assignment.", de);
return;
}
URI uri = getSourceURI(node);
if (uri == null) {
addError("Unable to get the URI for the source of this script!", de);
} else {
// Set the RHS to '= URI.create("string for this URI")'.
// That may throw an IllegalArgumentExpression wrapping the URISyntaxException.
de.setRightExpression(getExpression(uri));
}
}
/**
* Don't treat the LHS of a declaration as something we can wrap, just the RHS.
*
* @param expression
*/
@Override
public void visitDeclarationExpression(DeclarationExpression expression) {
expression.getRightExpression().visit(this);
}