Java TokenTypes.STRING_LITERAL属性代码示例

/**
 * Looks for all "safe" Token combinations in the argument
 * expression branch.
 * @param expr the argument expression
 * @return - true if any child matches the set of tokens, false if not
 */
private static boolean containsAllSafeTokens(final DetailAST expr) {
    DetailAST arg = expr.getFirstChild();
    arg = skipVariableAssign(arg);

    boolean argIsNotNull = false;
    if (arg.getType() == TokenTypes.PLUS) {
        DetailAST child = arg.getFirstChild();
        while (child != null
                && !argIsNotNull) {
            argIsNotNull = child.getType() == TokenTypes.STRING_LITERAL
                    || child.getType() == TokenTypes.IDENT;
            child = child.getNextSibling();
        }
    }

    return argIsNotNull
            || !arg.branchContains(TokenTypes.IDENT)
                && !arg.branchContains(TokenTypes.LITERAL_NULL);
}
 

/**
 * Returns the literal string expression represented by an AST.
 * @param ast an AST node for an EXPR
 * @return the Java string represented by the given AST expression
 *         or empty string if expression is too complex
 * @throws IllegalArgumentException if the AST is invalid
 */
private static String getStringExpr(DetailAST ast) {
    final DetailAST firstChild = ast.getFirstChild();
    String expr = "";

    switch (firstChild.getType()) {
        case TokenTypes.STRING_LITERAL:
            // NOTE: escaped characters are not unescaped
            final String quotedText = firstChild.getText();
            expr = quotedText.substring(1, quotedText.length() - 1);
            break;
        case TokenTypes.IDENT:
            expr = firstChild.getText();
            break;
        case TokenTypes.DOT:
            expr = firstChild.getLastChild().getText();
            break;
        default:
            // annotations with complex expressions cannot suppress warnings
    }
    return expr;
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.NUM_DOUBLE,
        TokenTypes.NUM_FLOAT,
        TokenTypes.NUM_INT,
        TokenTypes.NUM_LONG,
        TokenTypes.IDENT,
        TokenTypes.COMMENT_CONTENT,
        TokenTypes.STRING_LITERAL,
        TokenTypes.CHAR_LITERAL,
    };
}
 

@Override
public void visitToken(DetailAST ast) {
    // no need to check for nulls here, == and != always have two children
    final AST firstChild = ast.getFirstChild();
    final AST secondChild = firstChild.getNextSibling();

    if (firstChild.getType() == TokenTypes.STRING_LITERAL
            || secondChild.getType() == TokenTypes.STRING_LITERAL) {
        log(ast.getLineNo(), ast.getColumnNo(),
                MSG_KEY, ast.getText());
    }
}
 

@Override
public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.EXPR,
        TokenTypes.IDENT,
        TokenTypes.NUM_DOUBLE,
        TokenTypes.NUM_FLOAT,
        TokenTypes.NUM_INT,
        TokenTypes.NUM_LONG,
        TokenTypes.STRING_LITERAL,
        TokenTypes.LITERAL_NULL,
        TokenTypes.LITERAL_FALSE,
        TokenTypes.LITERAL_TRUE,
        TokenTypes.ASSIGN,
        TokenTypes.BAND_ASSIGN,
        TokenTypes.BOR_ASSIGN,
        TokenTypes.BSR_ASSIGN,
        TokenTypes.BXOR_ASSIGN,
        TokenTypes.DIV_ASSIGN,
        TokenTypes.MINUS_ASSIGN,
        TokenTypes.MOD_ASSIGN,
        TokenTypes.PLUS_ASSIGN,
        TokenTypes.SL_ASSIGN,
        TokenTypes.SR_ASSIGN,
        TokenTypes.STAR_ASSIGN,
        TokenTypes.LAMBDA,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.EXPR,
        TokenTypes.IDENT,
        TokenTypes.NUM_DOUBLE,
        TokenTypes.NUM_FLOAT,
        TokenTypes.NUM_INT,
        TokenTypes.NUM_LONG,
        TokenTypes.STRING_LITERAL,
        TokenTypes.LITERAL_NULL,
        TokenTypes.LITERAL_FALSE,
        TokenTypes.LITERAL_TRUE,
        TokenTypes.ASSIGN,
        TokenTypes.BAND_ASSIGN,
        TokenTypes.BOR_ASSIGN,
        TokenTypes.BSR_ASSIGN,
        TokenTypes.BXOR_ASSIGN,
        TokenTypes.DIV_ASSIGN,
        TokenTypes.MINUS_ASSIGN,
        TokenTypes.MOD_ASSIGN,
        TokenTypes.PLUS_ASSIGN,
        TokenTypes.SL_ASSIGN,
        TokenTypes.SR_ASSIGN,
        TokenTypes.STAR_ASSIGN,
        TokenTypes.LAMBDA,
    };
}
 

@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);
            }
        }
    }
}
 

@Test
public void testGetRequiredTokens() {
    final AvoidEscapedUnicodeCharactersCheck checkObj =
        new AvoidEscapedUnicodeCharactersCheck();
    final int[] expected = {
        TokenTypes.STRING_LITERAL,
        TokenTypes.CHAR_LITERAL,
    };
    assertArrayEquals("Required tokens differ from expected",
            expected, checkObj.getRequiredTokens());
}
 

@Test
public void testGetAcceptableTokens() {
    final AvoidEscapedUnicodeCharactersCheck check = new AvoidEscapedUnicodeCharactersCheck();
    final int[] actual = check.getAcceptableTokens();
    final int[] expected = {TokenTypes.STRING_LITERAL, TokenTypes.CHAR_LITERAL };
    assertArrayEquals("Acceptable tokens differ from expected",
            expected, actual);
}
 

@Override
public void visitToken(final DetailAST ast) {
    final DetailAST annotation = getSuppressWarnings(ast);

    if (annotation != null) {
        final DetailAST warningHolder =
            findWarningsHolder(annotation);

        final DetailAST token =
                warningHolder.findFirstToken(TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR);
        DetailAST warning;

        if (token == null) {
            warning = warningHolder.findFirstToken(TokenTypes.EXPR);
        }
        else {
            // case like '@SuppressWarnings(value = UNUSED)'
            warning = token.findFirstToken(TokenTypes.EXPR);
        }

        //rare case with empty array ex: @SuppressWarnings({})
        if (warning == null) {
            //check to see if empty warnings are forbidden -- are by default
            logMatch(warningHolder.getLineNo(),
                warningHolder.getColumnNo(), "");
        }
        else {
            while (warning != null) {
                if (warning.getType() == TokenTypes.EXPR) {
                    final DetailAST fChild = warning.getFirstChild();
                    switch (fChild.getType()) {
                        //typical case
                        case TokenTypes.STRING_LITERAL:
                            final String warningText =
                                removeQuotes(warning.getFirstChild().getText());
                            logMatch(warning.getLineNo(),
                                    warning.getColumnNo(), warningText);
                            break;
                        // conditional case
                        // ex:
                        // @SuppressWarnings((false) ? (true) ? "unchecked" : "foo" : "unused")
                        case TokenTypes.QUESTION:
                            walkConditional(fChild);
                            break;
                        // param in constant case
                        // ex: public static final String UNCHECKED = "unchecked";
                        // @SuppressWarnings(UNCHECKED)
                        // or
                        // @SuppressWarnings(SomeClass.UNCHECKED)
                        case TokenTypes.IDENT:
                        case TokenTypes.DOT:
                            break;
                        default:
                            // Known limitation: cases like @SuppressWarnings("un" + "used") or
                            // @SuppressWarnings((String) "unused") are not properly supported,
                            // but they should not cause exceptions.
                    }
                }
                warning = warning.getNextSibling();
            }
        }
    }
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {TokenTypes.STRING_LITERAL};
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {TokenTypes.STRING_LITERAL, TokenTypes.CHAR_LITERAL};
}
 

/**
 * Checks for calling equals on String literal and
 * anon object which cannot be null.
 * @param objCalledOn object AST
 * @return if it is string literal
 */
private static boolean isStringLiteral(DetailAST objCalledOn) {
    return objCalledOn.getType() == TokenTypes.STRING_LITERAL
            || objCalledOn.getType() == TokenTypes.LITERAL_NEW;
}