Java TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR属性代码示例

/**
 * Checks to see if the trailing comma is present if required or
 * prohibited.
 *
 * @param annotation the annotation token
 */
private void checkTrailingComma(final DetailAST annotation) {
    if (trailingArrayComma != TrailingArrayComma.IGNORE) {
        DetailAST child = annotation.getFirstChild();

        while (child != null) {
            DetailAST arrayInit = null;

            if (child.getType() == TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR) {
                arrayInit = child.findFirstToken(TokenTypes.ANNOTATION_ARRAY_INIT);
            }
            else if (child.getType() == TokenTypes.ANNOTATION_ARRAY_INIT) {
                arrayInit = child;
            }

            if (arrayInit != null) {
                logCommaViolation(arrayInit);
            }
            child = child.getNextSibling();
        }
    }
}
 

@Override
public void visitToken(DetailAST ast) {
    final int type = ast.getType();
    final DetailAST parent = ast.getParent();

    if (type == TokenTypes.LAMBDA && isLambdaSingleParameterSurrounded(ast)) {
        log(ast, MSG_LAMBDA, ast.getText());
    }
    else if (type != TokenTypes.ASSIGN
        || parent.getType() != TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR) {

        final boolean surrounded = isSurrounded(ast);
        // An identifier surrounded by parentheses.
        if (surrounded && type == TokenTypes.IDENT) {
            parentToSkip = ast.getParent();
            log(ast, MSG_IDENT, ast.getText());
        }
        // A literal (numeric or string) surrounded by parentheses.
        else if (surrounded && isInTokenList(type, LITERALS)) {
            parentToSkip = ast.getParent();
            if (type == TokenTypes.STRING_LITERAL) {
                log(ast, MSG_STRING,
                    chopString(ast.getText()));
            }
            else {
                log(ast, MSG_LITERAL, ast.getText());
            }
        }
        // The rhs of an assignment surrounded by parentheses.
        else if (isInTokenList(type, ASSIGNMENTS)) {
            assignDepth++;
            final DetailAST last = ast.getLastChild();
            if (last.getType() == TokenTypes.RPAREN) {
                log(ast, MSG_ASSIGN);
            }
        }
    }
}
 

@Override
public void leaveToken(DetailAST ast) {
    final int type = ast.getType();
    final DetailAST parent = ast.getParent();

    // shouldn't process assign in annotation pairs
    if (type != TokenTypes.ASSIGN
        || parent.getType() != TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR) {
        // An expression is surrounded by parentheses.
        if (type == TokenTypes.EXPR) {

            // If 'parentToSkip' == 'ast', then we've already logged a
            // warning about an immediate child node in visitToken, so we don't
            // need to log another one here.

            if (parentToSkip != ast && isExprSurrounded(ast)) {
                if (assignDepth >= 1) {
                    log(ast, MSG_ASSIGN);
                }
                else if (ast.getParent().getType() == TokenTypes.LITERAL_RETURN) {
                    log(ast, MSG_RETURN);
                }
                else {
                    log(ast, MSG_EXPR);
                }
            }

            parentToSkip = null;
        }
        else if (isInTokenList(type, ASSIGNMENTS)) {
            assignDepth--;
        }
    }
}
 

/**
 * Get all annotation values.
 * @param ast annotation token
 * @return list values
 */
private static List<String> getAllAnnotationValues(DetailAST ast) {
    // get values of annotation
    List<String> values = null;
    final DetailAST lparenAST = ast.findFirstToken(TokenTypes.LPAREN);
    if (lparenAST != null) {
        final DetailAST nextAST = lparenAST.getNextSibling();
        final int nextType = nextAST.getType();
        switch (nextType) {
            case TokenTypes.EXPR:
            case TokenTypes.ANNOTATION_ARRAY_INIT:
                values = getAnnotationValues(nextAST);
                break;

            case TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR:
                // expected children: IDENT ASSIGN ( EXPR |
                // ANNOTATION_ARRAY_INIT )
                values = getAnnotationValues(getNthChild(nextAST, 2));
                break;

            case TokenTypes.RPAREN:
                // no value present (not valid Java)
                break;

            default:
                // unknown annotation value type (new syntax?)
                throw new IllegalArgumentException("Unexpected AST: " + nextAST);
        }
    }
    return values;
}