protected void assertTypeNotNull(ClassNode type, AST rightNode) { if (type == null) { throw new ASTRuntimeException(rightNode, "No type available for: " + qualifiedName(rightNode)); } }
public static String qualifiedName(AST qualifiedNameNode) { if (isType(IDENT, qualifiedNameNode)) { return qualifiedNameNode.getText(); } if (isType(DOT, qualifiedNameNode)) { AST node = qualifiedNameNode.getFirstChild(); StringBuilder buffer = new StringBuilder(); boolean first = true; while (node != null && !isType(TYPE_ARGUMENTS, node)) { if (first) { first = false; } else { buffer.append("."); } buffer.append(qualifiedName(node)); node = node.getNextSibling(); } return buffer.toString(); } else { return qualifiedNameNode.getText(); } }
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 void throwsList(AST node, List<ClassNode> list) { String name; if (isType(DOT, node)) { name = qualifiedName(node); } else { name = identifier(node); } ClassNode exception = ClassHelper.make(name); configureAST(exception, node); list.add(exception); AST next = node.getNextSibling(); if (next != null) throwsList(next, list); }
private boolean checkTypeArgs(AST node, boolean seenTypeArgs) { if (isType(IDENT, node) && seenTypeArgs) { throw new ASTRuntimeException(node, "Unexpected type arguments found prior to: " + qualifiedName(node)); } if (isType(DOT, node)) { AST next = node.getFirstChild(); while (next != null && !isType(TYPE_ARGUMENTS, next)) { seenTypeArgs |= checkTypeArgs(next, seenTypeArgs); seenTypeArgs |= isType(TYPE_ARGUMENTS, next.getFirstChild()) || isType(TYPE_ARGUMENTS, next.getNextSibling()); next = next.getNextSibling(); } } return seenTypeArgs; }
protected ClassNode makeType(AST typeNode) { ClassNode answer = ClassHelper.DYNAMIC_TYPE; AST node = typeNode.getFirstChild(); if (node != null) { if (isType(INDEX_OP, node) || isType(ARRAY_DECLARATOR, node)) { answer = makeType(node).makeArray(); } else { checkTypeArgs(node, false); answer = ClassHelper.make(qualifiedName(node)); if (answer.isUsingGenerics()) { ClassNode newAnswer = ClassHelper.makeWithoutCaching(answer.getName()); newAnswer.setRedirect(answer); answer = newAnswer; } } configureAST(answer, node); } return answer; }
protected AnnotationNode annotation(AST annotationNode) { annotationBeingDef = true; AST node = annotationNode.getFirstChild(); String name = qualifiedName(node); AnnotationNode annotatedNode = new AnnotationNode(ClassHelper.make(name)); configureAST(annotatedNode, annotationNode); while (true) { node = node.getNextSibling(); if (isType(ANNOTATION_MEMBER_VALUE_PAIR, node)) { AST memberNode = node.getFirstChild(); String param = identifier(memberNode); Expression expression = expression(memberNode.getNextSibling()); if (annotatedNode.getMember(param) != null) { throw new ASTRuntimeException(memberNode, "Annotation member '" + param + "' has already been associated with a value"); } annotatedNode.setMember(param, expression); } else { break; } } annotationBeingDef = false; return annotatedNode; }
answer = ClassHelper.make(qualifiedName(node)); } else if (isPrimitiveTypeLiteral(node)) { answer = ClassHelper.make(node.getText());
String packageName = qualifiedName(packageNode); AST nameNode = packageNode.getNextSibling(); if (isType(STAR, nameNode)) {
protected void assertTypeNotNull(ClassNode type, AST rightNode) { if (type == null) { throw new ASTRuntimeException(rightNode, "No type available for: " + qualifiedName(rightNode)); } }
protected void assertTypeNotNull(ClassNode type, AST rightNode) { if (type == null) { throw new ASTRuntimeException(rightNode, "No type available for: " + qualifiedName(rightNode)); } }
protected void assertTypeNotNull(ClassNode type, AST rightNode) { if (type == null) { throw new ASTRuntimeException(rightNode, "No type available for: " + qualifiedName(rightNode)); } }
protected void assertTypeNotNull(ClassNode type, AST rightNode) { if (type == null) { throw new ASTRuntimeException(rightNode, "No type available for: " + qualifiedName(rightNode)); } }
protected void packageDef(AST packageDef) { AST node = packageDef.getFirstChild(); if (isType(ANNOTATIONS, node)) { node = node.getNextSibling(); } String name = qualifiedName(node); setPackageName(name); }
protected void packageDef(AST packageDef) { AST node = packageDef.getFirstChild(); if (isType(ANNOTATIONS, node)) { node = node.getNextSibling(); } String name = qualifiedName(node); setPackageName(name); }
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 void packageDef(AST packageDef) { AST node = packageDef.getFirstChild(); if (isType(ANNOTATIONS, node)) { node = node.getNextSibling(); } String name = qualifiedName(node); setPackageName(name); }
protected void throwsList(AST node, List<ClassNode> list) { String name; if (isType(DOT, node)) { name = qualifiedName(node); } else { name = identifier(node); } ClassNode exception = ClassHelper.make(name); configureAST(exception, node); list.add(exception); AST next = node.getNextSibling(); if (next != null) throwsList(next, list); }
protected void throwsList(AST node,List list) { String name; if (isType(DOT, node)) { name = qualifiedName(node); } else { name = identifier(node); } ClassNode exception = ClassHelper.make(name); configureAST(exception, node); list.add(exception); AST next = node.getNextSibling(); if (next!=null) throwsList(next, list); }
protected ClassNode makeType(AST typeNode) { ClassNode answer = ClassHelper.DYNAMIC_TYPE; AST node = typeNode.getFirstChild(); if (node != null) { if (isType(INDEX_OP, node) || isType(ARRAY_DECLARATOR, node)) { answer = makeType(node).makeArray(); } else { answer = ClassHelper.make(qualifiedName(node)); } configureAST(answer,node); } return answer; }