Parameter closureIndex = new Parameter(ClassHelper.int_TYPE, "__closureIndex"); ClosureExpression ce = new ClosureExpression(new Parameter[]{closureIndex}, bs); ce.setVariableScope(expression.getVariableScope());
clos.setVariableScope(new VariableScope()); MethodCallExpression stringOf = new MethodCallExpression(new VariableExpression("this"), "stringOf",
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(); }
private void createCloneSerialization(ClassNode cNode) { final BlockStatement body = new BlockStatement(); // def baos = new ByteArrayOutputStream() final Expression baos = varX("baos"); body.addStatement(declS(baos, ctorX(BAOS_TYPE))); // baos.withObjectOutputStream{ it.writeObject(this) } MethodCallExpression writeObject = callX(castX(OOS_TYPE, varX("it")), "writeObject", varX("this")); writeObject.setImplicitThis(false); ClosureExpression writeClos = closureX(block(stmt(writeObject))); writeClos.setVariableScope(new VariableScope()); body.addStatement(stmt(callX(baos, "withObjectOutputStream", args(writeClos)))); // def bais = new ByteArrayInputStream(baos.toByteArray()) final Expression bais = varX("bais"); body.addStatement(declS(bais, ctorX(BAIS_TYPE, args(callX(baos, "toByteArray"))))); // return bais.withObjectInputStream(getClass().classLoader){ (<type>) it.readObject() } MethodCallExpression readObject = callX(castX(OIS_TYPE, varX("it")), "readObject"); readObject.setImplicitThis(false); ClosureExpression readClos = closureX(block(stmt(castX(GenericsUtils.nonGeneric(cNode), readObject)))); readClos.setVariableScope(new VariableScope()); Expression classLoader = callX(callThisX("getClass"), "getClassLoader"); body.addStatement(returnS(callX(bais, "withObjectInputStream", args(classLoader, readClos)))); new VariableScopeVisitor(sourceUnit, true).visitClass(cNode); ClassNode[] exceptions = {make(CloneNotSupportedException.class)}; addGeneratedMethod(cNode, "clone", ACC_PUBLIC, GenericsUtils.nonGeneric(cNode), Parameter.EMPTY_ARRAY, exceptions, body); }
/** * Creates a closure expression. The statement passed as first parameter * becomes the closure's body. * <br><br> * * <strong>AST</strong> * <pre><code> * closureX(returnS(constantX("hello"))) // without params * closureX(statement, param("n",Integer)) // with a param * </code></pre> * * <strong>Result</strong> * <pre><code> * { -> "hello" } // without params * { Integer n -> n + 1 } // n + 1 is the statement * </code></pre> * * @param stmt the body of the closure * @param params the closure parameters * @return an instance of {@link ClosureExpression} * @since 0.1.5 */ public static ClosureExpression closureX(final Statement stmt, final Parameter... params) { final ClosureExpression expr = GeneralUtils.closureX(params, stmt); expr.setVariableScope(new VariableScope()); return expr; }
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; }
Parameter closureIndex = new Parameter(ClassHelper.int_TYPE, "__closureIndex"); ClosureExpression ce = new ClosureExpression(new Parameter[]{closureIndex}, bs); ce.setVariableScope(expression.getVariableScope());
private static Statement wrapStatements(Statement code, String threadingMethod) { // TODO deal with non-block statements if (!(code instanceof BlockStatement)) { return code; } BlockStatement codeBlock = (BlockStatement) code; List<Statement> statements = codeBlock.getStatements(); if (statements.isEmpty()) { return code; } VariableScope variableScope = codeBlock.getVariableScope(); BlockStatement block = new BlockStatement(); VariableScope blockScope = variableScope.copy(); makeVariablesShared(blockScope); block.setVariableScope(blockScope); ClosureExpression closure = new ClosureExpression(Parameter.EMPTY_ARRAY, code); VariableScope closureScope = variableScope.copy(); makeVariablesShared(closureScope); closure.setVariableScope(closureScope); block.addStatement(stmnt(new MethodCallExpression(THIS, threadingMethod, args(closure)))); return block; }
Parameter closureIndex = new Parameter(ClassHelper.int_TYPE, "__closureIndex"); ClosureExpression ce = new ClosureExpression(new Parameter[]{closureIndex}, bs); ce.setVariableScope(expression.getVariableScope());
rewrittenClosureExpression.setDeclaringClass(closureExpression.getDeclaringClass()); rewrittenClosureExpression.setSynthetic(true); rewrittenClosureExpression.setVariableScope(correctVariableScope(closureExpression.getVariableScope(), methodNode)); rewrittenClosureExpression.setType(closureExpression.getType());
clos.setVariableScope(new VariableScope()); MethodCallExpression stringOf = new MethodCallExpression(new VariableExpression("this"), "stringOf",
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(); }
rewrittenClosureExpression.setDeclaringClass(closureExpression.getDeclaringClass()); rewrittenClosureExpression.setSynthetic(true); rewrittenClosureExpression.setVariableScope(closureExpression.getVariableScope()); rewrittenClosureExpression.setType(closureExpression.getType());
public void visitClosureExpression(ClosureExpression expression) { pushState(); inClosure = true; // as result of the Paris meeting Closure resolves // always dynamically currentScope.setDynamicResolving(true); expression.setVariableScope(currentScope); if (expression.isParameterSpecified()) { Parameter[] parameters = expression.getParameters(); for (int i = 0; i < parameters.length; i++) { parameters[i].setInStaticContext(currentScope.isInStaticContext()); if (parameters[i].hasInitialExpression()) { parameters[i].getInitialExpression().visit(this); } declare(parameters[i], expression); } } else if (expression.getParameters() != null) { Parameter var = new Parameter(ClassHelper.OBJECT_TYPE,"it"); var.setInStaticContext(currentScope.isInStaticContext()); currentScope.putDeclaredVariable(var); } super.visitClosureExpression(expression); popState(); }
public void visitClosureExpression(ClosureExpression expression) { pushState(); inClosure = true; // as result of the Paris meeting Closure resolves // always dynamically currentScope.setDynamicResolving(true); expression.setVariableScope(currentScope); if (expression.isParameterSpecified()) { Parameter[] parameters = expression.getParameters(); for (int i = 0; i < parameters.length; i++) { parameters[i].setInStaticContext(currentScope.isInStaticContext()); if (parameters[i].hasInitialExpression()) { parameters[i].getInitialExpression().visit(this); } declare(parameters[i], expression); } } else if (expression.getParameters() != null) { Parameter var = new Parameter(ClassHelper.OBJECT_TYPE,"it"); var.setInStaticContext(currentScope.isInStaticContext()); currentScope.putDeclaredVariable(var); } super.visitClosureExpression(expression); popState(); }
private void handleNegation(List<String> propertyNames, BlockStatement newCode, NotExpression not, VariableScope variableScope) { Expression subExpression = not.getExpression(); if (subExpression instanceof BinaryExpression) { ArgumentListExpression arguments = new ArgumentListExpression(); BlockStatement currentBody = new BlockStatement(); ClosureExpression newClosureExpression = new ClosureExpression(new Parameter[0], currentBody); newClosureExpression.setVariableScope(new VariableScope()); arguments.addExpression(newClosureExpression); addBinaryExpressionToNewBody(propertyNames, currentBody, (BinaryExpression) subExpression, false, variableScope); newCode.addStatement(new ExpressionStatement(new MethodCallExpression(new VariableExpression("this"), "not", arguments))); } else { sourceUnit.getErrorCollector().addError(new LocatedMessage("You can only negate a binary expressions in queries.", Token.newString(not.getText(), not.getLineNumber(), not.getColumnNumber()), sourceUnit)); } }
newClosureExpression.setVariableScope(variableScope); arguments.addExpression(newClosureExpression); if (methodNameToCall != null) {
public void visitClosureExpression(ClosureExpression expression) { pushState(); inClosure = true; // as result of the Paris meeting Closure resolves // always dynamically currentScope.setDynamicResolving(true); expression.setVariableScope(currentScope); if (expression.isParameterSpecified()) { Parameter[] parameters = expression.getParameters(); for (int i = 0; i < parameters.length; i++) { parameters[i].setInStaticContext(currentScope.isInStaticContext()); if (parameters[i].hasInitialExpression()) { parameters[i].getInitialExpression().visit(this); } declare(parameters[i], expression); } } else if (expression.getParameters() != null) { Parameter var = new Parameter(ClassHelper.OBJECT_TYPE,"it"); var.setInStaticContext(currentScope.isInStaticContext()); currentScope.putDeclaredVariable(var); } super.visitClosureExpression(expression); popState(); }
private void createCloneSerialization(ClassNode cNode, List<FieldNode> list, List<String> excludes) { final BlockStatement body = new BlockStatement(); // def baos = new ByteArrayOutputStream() final Expression baos = new VariableExpression("baos"); body.addStatement(new ExpressionStatement(new DeclarationExpression(baos, ASSIGN, new ConstructorCallExpression(BAOS_TYPE, MethodCallExpression.NO_ARGUMENTS)))); // baos.withObjectOutputStream{ it.writeObject(this) } BlockStatement writeClosureCode = new BlockStatement(); final Expression it = new VariableExpression("it"); writeClosureCode.addStatement(new ExpressionStatement(new MethodCallExpression(it, "writeObject", VariableExpression.THIS_EXPRESSION))); ClosureExpression writeClosure = new ClosureExpression(new Parameter[]{}, writeClosureCode); writeClosure.setVariableScope(new VariableScope()); body.addStatement(new ExpressionStatement(new MethodCallExpression(baos, "withObjectOutputStream", new ArgumentListExpression(writeClosure)))); // def bais = new ByteArrayInputStream(baos.toByteArray()) final Expression bais = new VariableExpression("bais"); ConstructorCallExpression bytes = new ConstructorCallExpression(BAIS_TYPE, new TupleExpression(new MethodCallExpression(baos, "toByteArray", MethodCallExpression.NO_ARGUMENTS))); body.addStatement(new ExpressionStatement(new DeclarationExpression(bais, ASSIGN, bytes))); // return bais.withObjectInputStream(getClass().classLoader){ it.readObject() } BlockStatement readClosureCode = new BlockStatement(); readClosureCode.addStatement(new ExpressionStatement(new MethodCallExpression(it, "readObject", MethodCallExpression.NO_ARGUMENTS))); ClosureExpression readClosure = new ClosureExpression(new Parameter[]{}, readClosureCode); readClosure.setVariableScope(new VariableScope()); Expression klass = new MethodCallExpression(VariableExpression.THIS_EXPRESSION, "getClass", MethodCallExpression.NO_ARGUMENTS); Expression classLoader = new MethodCallExpression(klass, "getClassLoader", MethodCallExpression.NO_ARGUMENTS); Expression result = new MethodCallExpression(bais, "withObjectInputStream", new ArgumentListExpression(classLoader, readClosure)); body.addStatement(new ReturnStatement(result)); ClassNode[] exceptions = {ClassHelper.make(CloneNotSupportedException.class)}; cNode.addMethod("clone", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, new Parameter[0], exceptions, body); }
closureExpression.setVariableScope(variableScope); VariableExpression thisObject = new VariableExpression("this"); ClassNode delegateAsyncUtilsClassNode = new ClassNode(DelegateAsyncUtils.class);