@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); } }
/** * Construct the new {@link ClosureExpression} for the given build condition. */ @Nonnull public final ClosureExpression handleBuildCondition(@Nonnull ModelASTBuildCondition condition, @Nonnull ClosureExpression body) { body.setCode(handleBranch(condition.getBranch())); return body; }
private ClosureAndArguments build() { currentBody = new BlockStatement(); closureExpression = new ClosureExpression(new Parameter[0], currentBody); closureExpression.setVariableScope(variableScope); closureExpression.setCode(currentBody); arguments = new ArgumentListExpression(); arguments.addExpression(closureExpression); return 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(Collections.singletonList(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); } }
Statement code = ex.getCode(); code = createImplicitReturn(code); ex.setCode(new BlockStatement(new Statement[] {startStats,new TryCatchStatement(code,endStats)},ex.getVariableScope()));
Statement code = ex.getCode(); code = createImplicitReturn(code); ex.setCode(new BlockStatement(new Statement[] {startStats,new TryCatchStatement(code,endStats)},ex.getVariableScope()));
/** * Call {@link #transformStep(ModelASTStep, MethodCallExpression)} if appropriate, after handling any nested steps as well. */ @Nonnull public final MethodCallExpression handleStep(@Nonnull ModelASTStep step, @Nonnull MethodCallExpression methodCall) { // No transformation inside script blocks. if (step instanceof AbstractModelASTCodeBlock) { return methodCall; } TupleExpression originalArgs = (TupleExpression) methodCall.getArguments(); if (step instanceof ModelASTTreeStep && originalArgs.getExpressions().size() > 0) { ArgumentListExpression newArgs = new ArgumentListExpression(); // Technically we can't get here if there 0 expressions, so the loop below is safe. for (int i = 0; i < originalArgs.getExpressions().size() - 1; i++) { newArgs.addExpression(originalArgs.getExpression(i)); } ClosureExpression originalClosure = (ClosureExpression) originalArgs.getExpression(originalArgs.getExpressions().size() - 1); BlockStatement newBlock = block(); for (ModelASTStep nested : ((ModelASTTreeStep) step).getChildren()) { ExpressionStatement es = (ExpressionStatement) nested.getSourceLocation(); newBlock.addStatement(stmt(handleStep(nested, (MethodCallExpression)es.getExpression()))); } originalClosure.setCode(newBlock); newArgs.addExpression(originalClosure); methodCall.setArguments(newArgs); } return transformStep(step, methodCall); }
public void transformClosureExpression(ClassNode classNode, ClosureExpression closureExpression) { if (closureExpression.getNodeMetaData(TRANSFORMED_MARKER) != null) return; ClassNode previousClassNode = this.currentClassNode; try { this.currentClassNode = classNode; List<String> propertyNames = AstPropertyResolveUtils.getPropertyNames(classNode); Statement code = closureExpression.getCode(); BlockStatement newCode = new BlockStatement(); boolean addAll = false; if (code instanceof BlockStatement) { BlockStatement bs = (BlockStatement) code; addBlockStatementToNewQuery(bs, newCode, addAll, propertyNames, closureExpression.getVariableScope()); newCode.setVariableScope(bs.getVariableScope()); } if (!newCode.getStatements().isEmpty()) { closureExpression.putNodeMetaData(TRANSFORMED_MARKER, Boolean.TRUE); closureExpression.setCode(newCode); } } finally { this.currentClassNode = previousClassNode; } }