public static ClosureExpression closureX(Parameter[] params, Statement code) { return new ClosureExpression(params, code); }
protected ClosureExpression closureExpression(AST node) { AST paramNode = node.getFirstChild(); Parameter[] parameters = null; AST codeNode = paramNode; if (isType(PARAMETERS, paramNode) || isType(IMPLICIT_PARAMETERS, paramNode)) { parameters = parameters(paramNode); codeNode = paramNode.getNextSibling(); } Statement code = statementListNoChild(codeNode, node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); return closureExpression; }
protected Expression blockExpression(AST node) { AST codeNode = node.getFirstChild(); if (codeNode == null) return ConstantExpression.NULL; if (codeNode.getType() == EXPR && codeNode.getNextSibling() == null) { // Simplify common case of {expr} to expr. return expression(codeNode); } Parameter[] parameters = Parameter.EMPTY_ARRAY; Statement code = statementListNoChild(codeNode, node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); // Call it immediately. String callName = "call"; Expression noArguments = new ArgumentListExpression(); MethodCallExpression call = new MethodCallExpression(closureExpression, callName, noArguments); configureAST(call, node); return call; }
private static MethodCallExpression buildMemoizeClosureCallExpression(MethodNode privateMethod, int protectedCacheSize, int maxCacheSize) { Parameter[] srcParams = privateMethod.getParameters(); Parameter[] newParams = cloneParams(srcParams); List<Expression> argList = new ArrayList<Expression>(newParams.length); for (int i = 0; i < srcParams.length; i++) { argList.add(varX(newParams[i])); } ClosureExpression expression = new ClosureExpression( newParams, stmt(callThisX(privateMethod.getName(), args(argList))) ); MethodCallExpression mce; if (protectedCacheSize == 0 && maxCacheSize == 0) { mce = callX(expression, MEMOIZE_METHOD_NAME); } else if (protectedCacheSize == 0) { mce = callX(expression, MEMOIZE_AT_MOST_METHOD_NAME, args(constX(maxCacheSize))); } else if (maxCacheSize == 0) { mce = callX(expression, MEMOIZE_AT_LEAST_METHOD_NAME, args(constX(protectedCacheSize))); } else { mce = callX(expression, MEMOIZE_BETWEEN_METHOD_NAME, args(constX(protectedCacheSize), constX(maxCacheSize))); } mce.setImplicitThis(false); return mce; }
public void visit(ASTNode[] nodes, SourceUnit source) { init(nodes, source); AnnotatedNode parent = (AnnotatedNode) nodes[1]; AnnotationNode anno = (AnnotationNode) nodes[0]; if (!MY_TYPE.equals(anno.getClassNode())) return; if (parent instanceof ClassNode) { ClassNode cNode = (ClassNode) parent; if (!checkNotInterface(cNode, MY_TYPE_NAME)) return; ClassNode exception = getMemberClassValue(anno, "exception"); if (exception != null && Undefined.isUndefinedException(exception)) { exception = null; } String message = getMemberStringValue(anno, "message"); Expression code = anno.getMember("code"); if (code != null && !(code instanceof ClosureExpression)) { addError("Expected closure value for annotation parameter 'code'. Found " + code, cNode); return; } createMethods(cNode, exception, message, (ClosureExpression) code); if (code != null) { anno.setMember("code", new ClosureExpression(Parameter.EMPTY_ARRAY, EmptyStatement.INSTANCE)); } } }
bs.addStatement(seq); Parameter closureIndex = new Parameter(ClassHelper.int_TYPE, "__closureIndex"); ClosureExpression ce = new ClosureExpression(new Parameter[]{closureIndex}, bs); ce.setVariableScope(expression.getVariableScope());
reformatted.setSourcePosition(exp); ClosureExpression clos = new ClosureExpression(Parameter.EMPTY_ARRAY, new ExpressionStatement(reformatted)); clos.setVariableScope(new VariableScope()); MethodCallExpression stringOf = new MethodCallExpression(new VariableExpression("this"),
anno.setMember("pre", new ClosureExpression(Parameter.EMPTY_ARRAY, EmptyStatement.INSTANCE)); anno.setMember("post", new ClosureExpression(Parameter.EMPTY_ARRAY, EmptyStatement.INSTANCE));
anno.setMember("pre", new ClosureExpression(Parameter.EMPTY_ARRAY, EmptyStatement.INSTANCE)); anno.setMember("post", new ClosureExpression(Parameter.EMPTY_ARRAY, EmptyStatement.INSTANCE));
Parameter[] parameters = method.getParameters(); if (parameters.length == 0) parameters = null; // null means no implicit "it" ClosureExpression cl = new ClosureExpression(parameters, method.getCode()); visitClosureExpression(cl);
ClosureExpression closureExpression = new ClosureExpression(Parameter.EMPTY_ARRAY, code); configureAST(closureExpression, identifierNode); final PropertyExpression propertyExpression = new PropertyExpression(leftExpression, closureExpression);
public void visitMethodCallExpression(MethodCallExpression ex){ if(isTagCall(ex)){ //System.out.println("FOUND TAG CALL "+ex+" and rewriting "); List<Expression> args = ((TupleExpression)ex.getArguments()).getExpressions(); List<Expression> newArgs= new ArrayList<>(); newArgs.add(new ConstantExpression(ex.getMethodAsString())); newArgs.addAll(args); //Automatically add a closure so that scope is available to the tag if(newArgs.size()==0 || !(newArgs.get(newArgs.size()-1) instanceof ClosureExpression)){ newArgs.add(new ClosureExpression(new Parameter[0], new EmptyStatement())); } ex.setArguments(new TupleExpression(newArgs)); ex.setMethod(new ConstantExpression(TAG)); } super.visitMethodCallExpression(ex); } }
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; }
protected ClosureExpression closureExpression(AST node) { AST paramNode = node.getFirstChild(); Parameter[] parameters = null; AST codeNode = paramNode; if (isType(PARAMETERS, paramNode) || isType(IMPLICIT_PARAMETERS, paramNode)) { parameters = parameters(paramNode); codeNode = paramNode.getNextSibling(); } Statement code = statementListNoChild(codeNode,node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); return closureExpression; }
protected ClosureExpression closureExpression(AST node) { AST paramNode = node.getFirstChild(); Parameter[] parameters = null; AST codeNode = paramNode; if (isType(PARAMETERS, paramNode) || isType(IMPLICIT_PARAMETERS, paramNode)) { parameters = parameters(paramNode); codeNode = paramNode.getNextSibling(); } Statement code = statementListNoChild(codeNode,node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); return closureExpression; }
protected ClosureExpression closureExpression(AST node) { AST paramNode = node.getFirstChild(); Parameter[] parameters = null; AST codeNode = paramNode; if (isType(PARAMETERS, paramNode) || isType(IMPLICIT_PARAMETERS, paramNode)) { parameters = parameters(paramNode); codeNode = paramNode.getNextSibling(); } Statement code = statementListNoChild(codeNode, node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); return closureExpression; }
protected ClosureExpression closureExpression(AST node) { AST paramNode = node.getFirstChild(); Parameter[] parameters = null; AST codeNode = paramNode; if (isType(PARAMETERS, paramNode) || isType(IMPLICIT_PARAMETERS, paramNode)) { parameters = parameters(paramNode); codeNode = paramNode.getNextSibling(); } Statement code = statementListNoChild(codeNode,node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); return closureExpression; }
protected Expression blockExpression(AST node) { AST codeNode = node.getFirstChild(); if (codeNode == null) return ConstantExpression.NULL; if (codeNode.getType() == EXPR && codeNode.getNextSibling() == null) { // Simplify common case of {expr} to expr. return expression(codeNode); } Parameter[] parameters = Parameter.EMPTY_ARRAY; Statement code = statementListNoChild(codeNode, node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); // Call it immediately. String callName = "call"; Expression noArguments = new ArgumentListExpression(); MethodCallExpression call = new MethodCallExpression(closureExpression, callName, noArguments); configureAST(call, node); return call; }
protected Expression blockExpression(AST node) { AST codeNode = node.getFirstChild(); if (codeNode == null) return ConstantExpression.NULL; if (codeNode.getType() == EXPR && codeNode.getNextSibling() == null) { // Simplify common case of {expr} to expr. return expression(codeNode); } Parameter[] parameters = Parameter.EMPTY_ARRAY; Statement code = statementListNoChild(codeNode,node); ClosureExpression closureExpression = new ClosureExpression(parameters, code); configureAST(closureExpression, node); // Call it immediately. String callName = "call"; Expression noArguments = new ArgumentListExpression(); MethodCallExpression call = new MethodCallExpression(closureExpression, callName, noArguments); configureAST(call, node); return call; }
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)); } }