/** * Whether the declaration is located before the checked ast. * @param ast1 the IDENT ast of the declaration. * @param ast2 the IDENT ast to check. * @return true, if the declaration is located before the checked ast. */ private static boolean checkPosition(DetailAST ast1, DetailAST ast2) { boolean result = false; if (ast1.getLineNo() < ast2.getLineNo() || ast1.getLineNo() == ast2.getLineNo() && ast1.getColumnNo() < ast2.getColumnNo()) { result = true; } return result; }
@Override public void visitToken(DetailAST arrayInit) { final DetailAST rcurly = arrayInit.findFirstToken(TokenTypes.RCURLY); final DetailAST previousSibling = rcurly.getPreviousSibling(); if (arrayInit.getLineNo() != rcurly.getLineNo() && arrayInit.getChildCount() != 1 && rcurly.getLineNo() != previousSibling.getLineNo() && arrayInit.getLineNo() != previousSibling.getLineNo() && previousSibling.getType() != TokenTypes.COMMA) { log(rcurly.getLineNo(), MSG_KEY); } }
/** * Checks if ast2 is a chained method call that starts on the same level as ast1 ends. * In other words, if the right paren of ast1 is on the same level as the lparen of ast2: * * {@code * value.methodOne( * argument1 * ).methodTwo( * argument2 * ); * } * * @param ast1 Ast1 * @param ast2 Ast2 * @return True if ast2 begins on the same level that ast1 ends */ private static boolean areMethodsChained(DetailAST ast1, DetailAST ast2) { final DetailAST rparen = ast1.findFirstToken(TokenTypes.RPAREN); return rparen.getLineNo() == ast2.getLineNo(); }
/** * Checks whether {@link TokenTypes#RPAREN} is a closing paren * of a {@link TokenTypes#TYPECAST}. * @param ast of a {@link TokenTypes#RPAREN} to check. * @return true if ast is a closing paren of a {@link TokenTypes#TYPECAST}. */ private static boolean isInTypecast(DetailAST ast) { boolean result = false; if (ast.getParent().getType() == TokenTypes.TYPECAST) { final DetailAST firstRparen = ast.getParent().findFirstToken(TokenTypes.RPAREN); if (firstRparen.getLineNo() == ast.getLineNo() && firstRparen.getColumnNo() == ast.getColumnNo()) { result = true; } } return result; }
@Override public void leaveToken(DetailAST ast) { switch (ast.getType()) { case TokenTypes.SEMI: lastStatementEnd = ast.getLineNo(); forStatementEnd = -1; lambdaStatementEnd = -1; break; case TokenTypes.FOR_ITERATOR: inForHeader = false; break; case TokenTypes.LAMBDA: countOfSemiInLambda.pop(); if (countOfSemiInLambda.isEmpty()) { isInLambda = false; } lambdaStatementEnd = ast.getLineNo(); break; default: break; } }
@Override public void visitToken(DetailAST aAST) { final DetailAST mid = aAST.findFirstToken(TokenTypes.IDENT); final String name = mid.getText(); if ("clone".equals(name)) { final DetailAST params = aAST.findFirstToken(TokenTypes.PARAMETERS); final boolean hasEmptyParamList = params.findFirstToken(TokenTypes.PARAMETER_DEF) == null; if (hasEmptyParamList) { log(aAST.getLineNo(), MSG_KEY); } } }
/** * Process Import. * @param ast token * @param nextToken next token */ private void processImport(DetailAST ast, DetailAST nextToken) { if (nextToken.getType() != TokenTypes.IMPORT && nextToken.getType() != TokenTypes.STATIC_IMPORT && !hasEmptyLineAfter(ast)) { log(nextToken.getLineNo(), MSG_SHOULD_BE_SEPARATED, nextToken.getText()); } }
@Override public void visitToken(DetailAST ast) { final DetailAST typeAST = ast.getParent(); if (typeAST.getType() == TokenTypes.TYPE // Do not check method's return type. // We have no alternatives here. && typeAST.getParent().getType() != TokenTypes.METHOD_DEF) { final DetailAST variableAST = typeAST.getNextSibling(); if (variableAST != null) { final boolean isJavaStyle = variableAST.getLineNo() > ast.getLineNo() || variableAST.getColumnNo() - ast.getColumnNo() > -1; if (isJavaStyle != javaStyle) { log(ast, MSG_KEY); } } } }
@Override public void visitToken(DetailAST ast) { final String text = ast.getText(); final int colNo = ast.getColumnNo(); final int lineNo = ast.getLineNo(); final String currentLine = getLines()[lineNo - 1]; final String substringAfterToken = currentLine.substring(colNo + text.length()).trim(); final String substringBeforeToken = currentLine.substring(0, colNo).trim(); if (option == WrapOption.EOL && substringBeforeToken.isEmpty()) { log(ast, MSG_LINE_PREVIOUS, text); } else if (option == WrapOption.NL && substringAfterToken.isEmpty()) { log(ast, MSG_LINE_NEW, text); } }
final DetailAST rightCurly = slistAST.findFirstToken(TokenTypes.RCURLY); final DetailAST rcurlyAST; rcurlyAST = slistAST.getParent().findFirstToken(TokenTypes.RCURLY); final int slistLineNo = slistAST.getLineNo(); final int slistColNo = slistAST.getColumnNo(); final int rcurlyLineNo = rcurlyAST.getLineNo(); final int rcurlyColNo = rcurlyAST.getColumnNo(); final String[] lines = getLines(); boolean returnValue = false;
/** * Get string representation of the node as token name, * node text, line number and column number. * @param node DetailAST * @return node info */ private static String getNodeInfo(DetailAST node) { return TokenUtil.getTokenName(node.getType()) + " -> " + escapeAllControlChars(node.getText()) + " [" + node.getLineNo() + ':' + node.getColumnNo() + ']'; }
int lineStart = mainAst.findFirstToken(TokenTypes.IDENT).getLineNo(); final DetailAST typeNode = mainAst.findFirstToken(TokenTypes.TYPE); if (typeNode != null) { lineStart = getFirstLine(lineStart, typeNode); for (DetailAST node = mainAst.findFirstToken(TokenTypes.MODIFIERS).getFirstChild(); node != null; node = node.getNextSibling()) { if (node.getType() == TokenTypes.ANNOTATION) { continue; if (node.getLineNo() < lineStart) { lineStart = node.getLineNo();
/** * Checks whether block has a single-line format. * @param details for validation. * @return true if block has single-line format. */ private static boolean isSingleLineBlock(Details details) { final DetailAST rcurly = details.rcurly; final DetailAST lcurly = details.lcurly; DetailAST nextToken = details.nextToken; while (nextToken.getType() == TokenTypes.LITERAL_ELSE) { nextToken = Details.getNextToken(nextToken); } if (nextToken.getType() == TokenTypes.DO_WHILE) { final DetailAST doWhileSemi = nextToken.getParent().getLastChild(); nextToken = Details.getNextToken(doWhileSemi); } return rcurly.getLineNo() == lcurly.getLineNo() && rcurly.getLineNo() != nextToken.getLineNo(); }
@Override public void visitToken(DetailAST aAST) { final DetailAST mid = aAST.findFirstToken(TokenTypes.IDENT); final String name = mid.getText(); if ("finalize".equals(name)) { final DetailAST params = aAST.findFirstToken(TokenTypes.PARAMETERS); final boolean hasEmptyParamList = params.findFirstToken(TokenTypes.PARAMETER_DEF) == null; if (hasEmptyParamList) { log(aAST.getLineNo(), MSG_KEY); } } }
@Override public void visitToken(DetailAST ast) { final DetailAST openingBrace = ast.findFirstToken(TokenTypes.OBJBLOCK); if (openingBrace != null) { final DetailAST closingBrace = openingBrace.findFirstToken(TokenTypes.RCURLY); final int length = closingBrace.getLineNo() - openingBrace.getLineNo() + 1; if (length > max) { log(ast, MSG_KEY, length, max); } } }
@Override public String toString() { return String.join("", elements) + "[" + detailAst.getLineNo() + "x" + detailAst.getColumnNo() + "]"; }
@Override public void visitToken(DetailAST ast) { final DetailAST whitespaceFollowedAst = getWhitespaceFollowedNode(ast); if (whitespaceFollowedAst.getNextSibling() == null || whitespaceFollowedAst.getNextSibling().getType() != TokenTypes.ANNOTATIONS) { final int whitespaceColumnNo = getPositionAfter(whitespaceFollowedAst); final int whitespaceLineNo = whitespaceFollowedAst.getLineNo(); if (hasTrailingWhitespace(ast, whitespaceColumnNo, whitespaceLineNo)) { log(ast, MSG_KEY, whitespaceFollowedAst.getText()); } } }
private void forEachChild(DetailAST root) { for (DetailAST ast = root; ast != null; ast = ast.getNextSibling()) { if (ast.getType() == TokenTypes.SINGLE_LINE_COMMENT) { lineComments.add(ast.getLineNo() + "," + ast.getColumnNo()); } else if (ast.getType() == TokenTypes.BLOCK_COMMENT_BEGIN) { blockComments.add(ast.getLineNo() + "," + ast.getColumnNo()); } forEachChild(ast.getFirstChild()); } } }
@Override public void visitToken(DetailAST ast) { final String line = getLine(ast.getLineNo() - 1); final int before = ast.getColumnNo() - 1; if ((before == -1 || Character.isWhitespace(line.charAt(before))) && !isInEmptyForInitializerOrCondition(ast)) { boolean flag = !allowLineBreaks; // verify all characters before '.' are whitespace for (int i = 0; i <= before - 1; i++) { if (!Character.isWhitespace(line.charAt(i))) { flag = true; break; } } if (flag) { log(ast, MSG_KEY, ast.getText()); } } }