Java TokenTypes.ANNOTATION属性代码示例

@Override
public void visitToken(DetailAST ast) {
    DetailAST nodeWithAnnotations = ast;
    if (ast.getType() == TokenTypes.TYPECAST) {
        nodeWithAnnotations = ast.findFirstToken(TokenTypes.TYPE);
    }
    DetailAST modifiersNode = nodeWithAnnotations.findFirstToken(TokenTypes.MODIFIERS);
    if (modifiersNode == null) {
        modifiersNode = nodeWithAnnotations.findFirstToken(TokenTypes.ANNOTATIONS);
    }
    if (modifiersNode != null) {
        for (DetailAST annotationNode = modifiersNode.getFirstChild();
                annotationNode != null;
                annotationNode = annotationNode.getNextSibling()) {
            if (annotationNode.getType() == TokenTypes.ANNOTATION
                    && annotationNode.getLineNo() != getNextNode(annotationNode).getLineNo()) {
                log(annotationNode.getLineNo(), MSG_KEY_ANNOTATION_ON_SAME_LINE,
                      getAnnotationName(annotationNode));
            }
        }
    }
}
 

@Override
public void visitToken(DetailAST ast) {
    final List<DetailAST> mods = new ArrayList<DetailAST>();
    DetailAST modifier = ast.getFirstChild();
    while (modifier != null) {
        mods.add(modifier);
        modifier = modifier.getNextSibling();
    }

    if (!mods.isEmpty()) {
        final DetailAST error = checkOrderSuggestedByJls(mods);
        if (error != null) {
            if (error.getType() == TokenTypes.ANNOTATION) {
                log(error.getLineNo(), error.getColumnNo(),
                        MSG_ANNOTATION_ORDER,
                         error.getFirstChild().getText()
                         + error.getFirstChild().getNextSibling()
                            .getText());
            }
            else {
                log(error.getLineNo(), error.getColumnNo(),
                        MSG_MODIFIER_ORDER, error.getText());
            }
        }
    }
}
 

/**
 * Checks whether a method is annotated with Override annotation.
 * @param ast method parameter definition token.
 * @return true if a method is annotated with Override annotation.
 */
private static boolean isOverriddenMethod(DetailAST ast) {
    boolean overridden = false;

    final DetailAST parent = ast.getParent().getParent();
    final Optional<DetailAST> annotation =
        Optional.ofNullable(parent.getFirstChild().getFirstChild());

    if (annotation.isPresent()
            && annotation.get().getType() == TokenTypes.ANNOTATION) {
        final Optional<DetailAST> overrideToken =
            Optional.ofNullable(annotation.get().findFirstToken(TokenTypes.IDENT));
        if (overrideToken.isPresent() && "Override".equals(overrideToken.get().getText())) {
            overridden = true;
        }
    }
    return overridden;
}
 

/**
 * Returns array of acceptable tokens.
 * @return acceptableTokens.
 */
private static int[] makeAcceptableTokens() {
    return new int[] {TokenTypes.ANNOTATION,
        TokenTypes.ANNOTATION_FIELD_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.CTOR_DEF,
        TokenTypes.DOT,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.EXPR,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_NEW,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.METHOD_CALL,
        TokenTypes.METHOD_DEF,
        TokenTypes.QUESTION,
        TokenTypes.RESOURCE_SPECIFICATION,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LAMBDA,
    };
}
 

/**
 * Some javadoc.
 * @param methodDef Some javadoc.
 * @return Some javadoc.
 */
private boolean hasAllowedAnnotations(DetailAST methodDef) {
    boolean result = false;
    final DetailAST modifiersNode = methodDef.findFirstToken(TokenTypes.MODIFIERS);
    DetailAST annotationNode = modifiersNode.findFirstToken(TokenTypes.ANNOTATION);
    while (annotationNode != null && annotationNode.getType() == TokenTypes.ANNOTATION) {
        DetailAST identNode = annotationNode.findFirstToken(TokenTypes.IDENT);
        if (identNode == null) {
            identNode = annotationNode.findFirstToken(TokenTypes.DOT)
                .findFirstToken(TokenTypes.IDENT);
        }
        if (allowedAnnotations.contains(identNode.getText())) {
            result = true;
            break;
        }
        annotationNode = annotationNode.getNextSibling();
    }
    return result;
}
 

/**
 * @return the tokens that are delivered from the parser to this class.
 */
@Override
public int[] getDefaultTokens() {
	return new int[] { TokenTypes.ABSTRACT, TokenTypes.PACKAGE_DEF, TokenTypes.INTERFACE_DEF, TokenTypes.CLASS_DEF,
			TokenTypes.ANNOTATION, TokenTypes.IMPORT, TokenTypes.IMPLEMENTS_CLAUSE, TokenTypes.EXTENDS_CLAUSE,
			TokenTypes.TYPE };
}
 

public static List<DetailAST> getValueAsAnnotations(DetailAST annotationKeyValueAst) {
  // can be in curly bracket or only one annotation!
  DetailAST annotationValueNode = getAnnotationValueNode(annotationKeyValueAst);
  return annotationValueNode.getType() == TokenTypes.ANNOTATION ?
      Collections.singletonList(annotationValueNode) :
      CommonUtil.getChildsByType(annotationValueNode, TokenTypes.ANNOTATION);
}
 

/**
 * Retrieves the first modifier that is not an annotation.
 * @param modifiers The ast to examine.
 * @return The first modifier or {@code null} if none found.
 */
private static DetailAST getFirstModifierAst(DetailAST modifiers) {
    DetailAST modifier = modifiers.getFirstChild();

    while (modifier != null && modifier.getType() == TokenTypes.ANNOTATION) {
        modifier = modifier.getNextSibling();
    }

    return modifier;
}
 

/**
 * Gets the list of annotations on method definition.
 * @param methodDef method definition node
 * @return List of annotations
 */
private static List<DetailAST> getMethodAnnotationsList(DetailAST methodDef) {
    final List<DetailAST> annotationsList = new ArrayList<DetailAST>();
    final DetailAST modifiers = methodDef.findFirstToken(TokenTypes.MODIFIERS);
    DetailAST modifier = modifiers.getFirstChild();
    while (modifier != null) {
        if (modifier.getType() == TokenTypes.ANNOTATION) {
            annotationsList.add(modifier);
        }
        modifier = modifier.getNextSibling();
    }
    return annotationsList;
}
 

/**
 * Node is on enum constant.
 * @param blockComment DetailAST
 * @return true if node is before enum constant
 */
public static boolean isOnEnumConstant(DetailAST blockComment) {
    final boolean isOnPlainConst = blockComment.getParent() != null
            && blockComment.getParent().getType() == TokenTypes.ENUM_CONSTANT_DEF
            && getPrevSiblingSkipComments(blockComment).getType() == TokenTypes.ANNOTATIONS
            && getPrevSiblingSkipComments(blockComment).getChildCount() == 0;
    final boolean isOnConstWithAnnotation = !isOnPlainConst && blockComment.getParent() != null
            && blockComment.getParent().getType() == TokenTypes.ANNOTATION
            && blockComment.getParent().getParent().getParent().getType()
                == TokenTypes.ENUM_CONSTANT_DEF;
    return isOnPlainConst || isOnConstWithAnnotation;
}
 

/**
 * Skip all annotations in modifier block.
 * @param modifierIterator iterator for collection of modifiers
 * @return modifier next to last annotation
 */
private static DetailAST skipAnnotations(Iterator<DetailAST> modifierIterator) {
    DetailAST modifier;
    do {
        modifier = modifierIterator.next();
    } while (modifierIterator.hasNext() && modifier.getType() == TokenTypes.ANNOTATION);
    return modifier;
}
 

/**
 * Find the last token of type {@code TokenTypes.ANNOTATION}
 * under the given set of modifiers.
 * @param modifiers {@code DetailAST}.
 * @return {@code DetailAST} or null if there are no annotations.
 */
private static DetailAST findLastAnnotation(DetailAST modifiers) {
    DetailAST annotation = modifiers.findFirstToken(TokenTypes.ANNOTATION);
    while (annotation != null && annotation.getNextSibling() != null
           && annotation.getNextSibling().getType() == TokenTypes.ANNOTATION) {
        annotation = annotation.getNextSibling();
    }
    return annotation;
}
 

@Override
public void visitToken(DetailAST ast) {
    switch (ast.getType()) {
        case TokenTypes.METHOD_CALL:
            processLeft(ast);
            processRight(ast.findFirstToken(TokenTypes.RPAREN));
            break;
        case TokenTypes.DOT:
        case TokenTypes.EXPR:
        case TokenTypes.QUESTION:
            processExpression(ast);
            break;
        case TokenTypes.LITERAL_FOR:
            visitLiteralFor(ast);
            break;
        case TokenTypes.ANNOTATION:
        case TokenTypes.ENUM_CONSTANT_DEF:
        case TokenTypes.LITERAL_NEW:
        case TokenTypes.LITERAL_SYNCHRONIZED:
        case TokenTypes.LAMBDA:
            visitTokenWithOptionalParentheses(ast);
            break;
        case TokenTypes.RESOURCE_SPECIFICATION:
            visitResourceSpecification(ast);
            break;
        default:
            processLeft(ast.findFirstToken(TokenTypes.LPAREN));
            processRight(ast.findFirstToken(TokenTypes.RPAREN));
    }
}
 

/**
 * Checks to see if the AST is annotated with
 * the passed in annotation and return the AST
 * representing that annotation.
 *
 * <p>
 * This method will not look for imports or package
 * statements to detect the passed in annotation.
 * </p>
 *
 * <p>
 * To check if an AST contains a passed in annotation
 * taking into account fully-qualified names
 * (ex: java.lang.Override, Override)
 * this method will need to be called twice. Once for each
 * name given.
 * </p>
 *
 * @param ast the current node
 * @param annotation the annotation name to check for
 * @return the AST representing that annotation
 */
public static DetailAST getAnnotation(final DetailAST ast,
    String annotation) {
    if (ast == null) {
        throw new IllegalArgumentException(THE_AST_IS_NULL);
    }

    if (annotation == null) {
        throw new IllegalArgumentException("the annotation is null");
    }

    if (CommonUtils.isBlank(annotation)) {
        throw new IllegalArgumentException(
                "the annotation is empty or spaces");
    }

    final DetailAST holder = getAnnotationHolder(ast);
    DetailAST result = null;
    for (DetailAST child = holder.getFirstChild();
        child != null; child = child.getNextSibling()) {
        if (child.getType() == TokenTypes.ANNOTATION) {
            final DetailAST firstChild = child.findFirstToken(TokenTypes.AT);
            final String name =
                FullIdent.createFullIdent(firstChild.getNextSibling()).getText();
            if (annotation.equals(name)) {
                result = child;
                break;
            }
        }
    }

    return result;
}
 

@Override
public int[] getDefaultTokens() {
    return new int[] {TokenTypes.ANNOTATION};
}