protected String label(AST labelNode) { AST node = labelNode.getFirstChild(); if (node == null) { return null; } return identifier(node); }
protected ClassNode[] interfaces(AST node) { List<ClassNode> interfaceList = new ArrayList<ClassNode>(); for (AST implementNode = node.getFirstChild(); implementNode != null; implementNode = implementNode.getNextSibling()) { interfaceList.add(makeTypeWithArguments(implementNode)); } ClassNode[] interfaces = ClassNode.EMPTY_ARRAY; if (!interfaceList.isEmpty()) { interfaces = new ClassNode[interfaceList.size()]; interfaceList.toArray(interfaces); } return interfaces; }
protected Expression spreadExpression(AST node) { AST exprNode = node.getFirstChild(); AST listNode = exprNode.getFirstChild(); Expression right = expression(listNode); SpreadExpression spreadExpression = new SpreadExpression(right); configureAST(spreadExpression, node); return spreadExpression; }
protected Statement statementList(AST code) { BlockStatement block = siblingsToBlockStatement(code.getFirstChild()); configureAST(block, code); return block; }
protected void dumpTree(AST ast) { for (AST node = ast.getFirstChild(); node != null; node = node.getNextSibling()) { dump(node); } }
private void processAnnotations(List<AnnotationNode> annotations, AST node) { AST child = node.getFirstChild(); while (child != null) { if (isType(ANNOTATION, child)) annotations.add(annotation(child)); child = child.getNextSibling(); } }
private List<GenericsType> getTypeArgumentsList(AST node) { assertNodeType(TYPE_ARGUMENTS, node); List<GenericsType> typeArgumentList = new LinkedList<GenericsType>(); AST typeArgument = node.getFirstChild(); while (typeArgument != null) { assertNodeType(TYPE_ARGUMENT, typeArgument); GenericsType gt = makeGenericsArgumentType(typeArgument); typeArgumentList.add(gt); typeArgument = typeArgument.getNextSibling(); } return typeArgumentList; }
protected Expression spreadMapExpression(AST node) { AST exprNode = node.getFirstChild(); Expression expr = expression(exprNode); SpreadMapExpression spreadMapExpression = new SpreadMapExpression(expr); configureAST(spreadMapExpression, node); return spreadMapExpression; }
protected Expression specialConstructorCallExpression(AST methodCallNode, ClassNode special) { AST node = methodCallNode.getFirstChild(); Expression arguments = arguments(node); ConstructorCallExpression expression = new ConstructorCallExpression(special, arguments); configureAST(expression, methodCallNode); return expression; }
private void dumpTree(AST ast, String offset) { dump(ast, offset); for (AST node = ast.getFirstChild(); node != null; node = node.getNextSibling()) { dumpTree(node, offset+"\t"); } }
protected Statement returnStatement(AST node) { AST exprNode = node.getFirstChild(); // This will pick up incorrect sibling node if 'node' is a plain 'return' // //if (exprNode == null) { // exprNode = node.getNextSibling(); //} Expression expression = exprNode == null ? ConstantExpression.NULL : expression(exprNode); ReturnStatement returnStatement = new ReturnStatement(expression); configureAST(returnStatement, node); return returnStatement; }
protected Expression asExpression(AST node) { AST leftNode = node.getFirstChild(); Expression leftExpression = expression(leftNode); AST rightNode = leftNode.getNextSibling(); ClassNode type = makeTypeWithArguments(rightNode); return CastExpression.asExpression(type, leftExpression); }
protected Expression postfixExpression(AST node, int token) { Expression expression = expression(node.getFirstChild()); PostfixExpression postfixExpression = new PostfixExpression(expression, makeToken(token, node)); configureAST(postfixExpression, node); return postfixExpression; }
protected void packageDef(AST packageDef) { List<AnnotationNode> annotations = new ArrayList<AnnotationNode>(); AST node = packageDef.getFirstChild(); if (isType(ANNOTATIONS, node)) { processAnnotations(annotations, node); node = node.getNextSibling(); } String name = qualifiedName(node); // TODO should we check package node doesn't already exist? conflict? PackageNode packageNode = setPackage(name, annotations); configureAST(packageNode, packageDef); }
protected Expression rangeExpression(AST rangeNode, boolean inclusive) { AST node = rangeNode.getFirstChild(); Expression left = expression(node); Expression right = expression(node.getNextSibling()); RangeExpression rangeExpression = new RangeExpression(left, right, inclusive); configureAST(rangeExpression, rangeNode); return rangeExpression; }
@Override public void visitMultiCatch(final GroovySourceAST t, final int visit) { if (visit == CLOSING_VISIT) { final AST child = t.getFirstChild(); if ("MULTICATCH_TYPES".equals(child.getText())) { print(t, visit, null, null, " "+child.getNextSibling().getText()); } else { print(t, visit, null, null, " "+child.getFirstChild().getText()); } } }
protected Statement synchronizedStatement(AST syncNode) { AST node = syncNode.getFirstChild(); Expression expression = expression(node); Statement code = statement(node.getNextSibling()); SynchronizedStatement synchronizedStatement = new SynchronizedStatement(expression, code); configureAST(synchronizedStatement, syncNode); return synchronizedStatement; }
protected Statement throwStatement(AST node) { AST expressionNode = node.getFirstChild(); if (expressionNode == null) { expressionNode = node.getNextSibling(); } if (expressionNode == null) { throw new ASTRuntimeException(node, "No expression available"); } ThrowStatement throwStatement = new ThrowStatement(expression(expressionNode)); configureAST(throwStatement, node); return throwStatement; }
protected Expression castExpression(AST castNode) { AST node = castNode.getFirstChild(); ClassNode type = makeTypeWithArguments(node); assertTypeNotNull(type, node); AST expressionNode = node.getNextSibling(); Expression expression = expression(expressionNode); CastExpression castExpression = new CastExpression(type, expression); configureAST(castExpression, castNode); return castExpression; }
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; }