/** * Returns the top-level statements in the specified closure definition. * If no such statements are found, an empty list is returned. * * @param expr a ClosureExpression representing a closure defintion * @return the top-level statements in the specified closure definition */ public List<Statement> getStatements(ClosureExpression expr) { return getStatements((BlockStatement)expr.getCode()); }
@SuppressWarnings("unchecked") public static List<Statement> getStatements(ClosureExpression closure) { BlockStatement blockStat = (BlockStatement)closure.getCode(); return blockStat == null ? Collections.<Statement> emptyList() : // it's not possible to add any statements to such a ClosureExpression, so immutable list is OK blockStat.getStatements(); }
private Map<String, ClassNode> extractModelTypesFromClosureExpression(final ClosureExpression expression) { Map<String, ClassNode> model = new HashMap<String, ClassNode>(); extractModelTypesFromStatement(expression.getCode(), model); return model; }
public void visitClosureExpression(ClosureExpression expression) { expression.getCode().visit(this); }
public void visitClosureExpression(final ClosureExpression expression) { assertExpressionAuthorized(expression); if (!isClosuresAllowed) throw new SecurityException("Closures are not allowed"); expression.getCode().visit(this); }
@Override public void visitClosureExpression(final ClosureExpression expression) { super.visitClosureExpression(expression); if (inBuilderMethod) { Statement oldCode = expression.getCode(); BlockStatement block = oldCode instanceof BlockStatement? ((BlockStatement)oldCode): new BlockStatement(Arrays.asList(oldCode), new VariableScope()); List<Statement> statements = block.getStatements(); if (!statements.isEmpty()) { Statement first = statements.get(0); Statement last = statements.get(statements.size()-1); if (expression.getLineNumber()<first.getLineNumber()) { // there's a new line between { -> ... and the first statement statements.add(0,createNewLine(expression)); } if (expression.getLastLineNumber()>last.getLastLineNumber()) { // there's a new line between { -> ... and the first statement statements.add(createNewLine(expression)); } } expression.setCode(block); } }
public static boolean copyStatementsWithSuperAdjustment(ClosureExpression pre, BlockStatement body) { Statement preCode = pre.getCode(); boolean changed = false; if (preCode instanceof BlockStatement) { BlockStatement block = (BlockStatement) preCode; List<Statement> statements = block.getStatements(); for (int i = 0; i < statements.size(); i++) { Statement statement = statements.get(i); // adjust the first statement if it's a super call if (i == 0 && statement instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) statement; Expression preExp = es.getExpression(); if (preExp instanceof MethodCallExpression) { MethodCallExpression mce = (MethodCallExpression) preExp; String name = mce.getMethodAsString(); if ("super".equals(name)) { es.setExpression(new ConstructorCallExpression(ClassNode.SUPER, mce.getArguments())); changed = true; } } } body.addStatement(statement); } } return changed; }
@Override public Expression transform(Expression exp) { if (exp instanceof ClosureExpression) { ClosureExpression ce = (ClosureExpression) exp; ce.getCode().visit(this); } else if (exp instanceof VariableExpression) { VariableExpression ve = (VariableExpression) exp; if ("args".equals(ve.getName()) && ve.getAccessedVariable() instanceof DynamicVariable) { VariableExpression newVe = varX(param(MAP_TYPE, "args")); newVe.setSourcePosition(ve); return newVe; } } return exp.transformExpression(this); }
Expression transformClosureExpression(final ClosureExpression expr) { Parameter[] parameters = expr.getParameters(); if (parameters!=null) { for (Parameter parameter : parameters) { if (parameter.hasInitialExpression()) { parameter.setInitialExpression(transformer.transform(parameter.getInitialExpression())); } } } Statement code = expr.getCode(); transformer.visitClassCodeContainer(code); return transformer.superTransform(expr); }
protected Expression transformClosureExpression(ClosureExpression ce) { boolean oldInClosure = inClosure; inClosure = true; if (ce.getParameters() != null) { for (Parameter p : ce.getParameters()) { if (p.hasInitialExpression()) { p.setInitialExpression(transform(p.getInitialExpression())); } } } Statement code = ce.getCode(); if (code != null) code.visit(this); inClosure = oldInClosure; return ce; }
ce.getCode().visit(this); varStack.removeLast();
if (post != null) { ClosureExpression transformed = (ClosureExpression) transformer.transform(post); body.addStatement(transformed.getCode());
private BlockStatement methodBody(ClassNode exception, String message, ClosureExpression code, ClassNode returnType) { BlockStatement body = new BlockStatement(); if (code != null) { body.addStatement(code.getCode()); } else if (exception != null) { body.addStatement(throwS(ctorX(exception, message == null ? EMPTY_ARGUMENTS : constX(message)))); } else { Expression result = getDefaultValueForPrimitive(returnType); if (result != null) { body.addStatement(returnS(result)); } } return body; } }
protected Expression transformClosureExpression(ClosureExpression ce) { boolean oldInClosure = inClosure; inClosure = true; Parameter[] paras = ce.getParameters(); if (paras != null) { for (Parameter para : paras) { ClassNode t = para.getType(); resolveOrFail(t, ce); visitAnnotations(para); if (para.hasInitialExpression()) { para.setInitialExpression(transform(para.getInitialExpression())); } visitAnnotations(para); } } Statement code = ce.getCode(); if (code != null) code.visit(this); inClosure = oldInClosure; return ce; }
body.addStatement(post.getCode());
Statement code = expression.getCode(); code.visit(new VariableExpressionTypeMemoizer(varOrigType)); Map<VariableExpression, List<ClassNode>> oldTracker = pushAssignmentTracking();
cl.getCode().visit(this); return cl;
} else if (expr instanceof ClosureExpression) { ClosureExpression ce = (ClosureExpression) expr; ce.getCode().visit(this); } else if (expr instanceof ConstructorCallExpression) { ConstructorCallExpression cce = (ConstructorCallExpression) expr;
answer.addMethod("doCall", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, parameters, ClassNode.EMPTY_ARRAY, expression.getCode()); method.setSourcePosition(expression);