/** * Returns the name of the given annotation. * @param annotation annotation node. * @return annotation name. */ private static String getAnnotationName(DetailAST annotation) { DetailAST identNode = annotation.findFirstToken(TokenTypes.IDENT); if (identNode == null) { identNode = annotation.findFirstToken(TokenTypes.DOT).findFirstToken(TokenTypes.IDENT); } return identNode.getText(); }
@Override public void visitToken(DetailAST ast) { final DetailAST modifiers = ast.findFirstToken(TokenTypes.MODIFIERS); if (modifiers.findFirstToken(TokenTypes.ABSTRACT) == null && ast.findFirstToken(TokenTypes.OBJBLOCK) .findFirstToken(TokenTypes.CTOR_DEF) == null) { log(ast.getLineNo(), MSG_KEY); } }
/** * Retrieves the right side of a conditional. * * @param cond a conditional type * {@link TokenTypes#QUESTION QUESTION} * @return either the value * or another conditional */ private static DetailAST getCondRight(final DetailAST cond) { final DetailAST colon = cond.findFirstToken(TokenTypes.COLON); return colon.getNextSibling(); }
@Override public boolean isValidOn(final DetailAST ast) { final int astType = ast.getType(); final DetailAST varType = ast.findFirstToken(TokenTypes.TYPE); return astType == TokenTypes.VARIABLE_DEF && varType.getFirstChild().getType() == TokenTypes.ARRAY_DECLARATOR && "ObjectStreamField".equals(varType.getFirstChild().getText()); }
@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); } }
/** * Check if given parameter definition is a multiple type catch. * @param parameterDefAst parameter definition * @return true if it is a multiple type catch, false otherwise */ private static boolean isMultipleTypeCatch(DetailAST parameterDefAst) { final DetailAST typeAst = parameterDefAst.findFirstToken(TokenTypes.TYPE); return typeAst.getFirstChild().getType() == TokenTypes.BOR; }
/** * Checks for compact style type violations. * * @param annotation the annotation token */ private void checkCompactStyle(final DetailAST annotation) { final int valuePairCount = annotation.getChildCount( TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR); final DetailAST valuePair = annotation.findFirstToken( TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR); if (valuePairCount == 1 && ANNOTATION_ELEMENT_SINGLE_NAME.equals( valuePair.getFirstChild().getText())) { log(annotation.getLineNo(), MSG_KEY_ANNOTATION_INCORRECT_STYLE, ElementStyle.COMPACT); } }
/** * Returns generic type arguments token. * @param type type token. * @param isCanonicalName whether type name is in canonical form. * @return generic type arguments token. */ private static DetailAST getGenericTypeArgs(DetailAST type, boolean isCanonicalName) { final DetailAST typeArgs; if (isCanonicalName) { // if type class name is in canonical form, abstract tree has specific structure typeArgs = type.getFirstChild().findFirstToken(TokenTypes.TYPE_ARGUMENTS); } else { typeArgs = type.findFirstToken(TokenTypes.TYPE_ARGUMENTS); } return typeArgs; }
@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); } } }
/** * Finds the class body of the first class in the DetailAST. * @param top AST to find the class body * @return OBJBLOCK token if found; {@code null} otherwise */ private static DetailAST getClassBody(DetailAST top) { DetailAST ast = top; while (ast != null && ast.getType() != TokenTypes.CLASS_DEF) { ast = ast.getNextSibling(); } DetailAST objBlock = null; if (ast != null) { objBlock = ast.findFirstToken(TokenTypes.OBJBLOCK); } return objBlock; }
/** * Checks whether a parameter is a receiver. * * @param parameterDefAst the parameter node. * @return true if the parameter is a receiver. */ public static boolean isReceiverParameter(DetailAST parameterDefAst) { return parameterDefAst.getType() == TokenTypes.PARAMETER_DEF && parameterDefAst.findFirstToken(TokenTypes.IDENT) == null; }
/** * Checks variable definition. * @param ast variable def node for check */ private void visitVariableDef(DetailAST ast) { if (checking && ast.getParent().getType() == TokenTypes.OBJBLOCK) { final DetailAST modifiersAST = ast.findFirstToken(TokenTypes.MODIFIERS); if (modifiersAST.findFirstToken(TokenTypes.FINAL) == null) { log(ast, MSG_KEY, ast.findFirstToken(TokenTypes.IDENT).getText()); } } }
/** * Check the indentation level of modifiers. */ protected void checkModifiers() { final DetailAST modifiers = mainAst.findFirstToken(TokenTypes.MODIFIERS); for (DetailAST modifier = modifiers.getFirstChild(); modifier != null; modifier = modifier.getNextSibling()) { if (isOnStartOfLine(modifier) && !getIndent().isAcceptable(expandedTabsColumnNo(modifier))) { logError(modifier, "modifier", expandedTabsColumnNo(modifier)); } } }
/** * 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()) { final Optional<DetailAST> overrideToken = Optional.ofNullable(annotation.get().findFirstToken(TokenTypes.IDENT)); if (overrideToken.isPresent() && "Override".equals(overrideToken.get().getText())) { overridden = true; } } return overridden; }
/** * 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<>(); 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; }
/** * Gets variable's name associated with exception. * @param catchAst {@link TokenTypes#LITERAL_CATCH LITERAL_CATCH} * @return Variable's name associated with exception. */ private static String getExceptionVariableName(DetailAST catchAst) { final DetailAST parameterDef = catchAst.findFirstToken(TokenTypes.PARAMETER_DEF); final DetailAST variableName = parameterDef.findFirstToken(TokenTypes.IDENT); return variableName.getText(); }
/** * Get the child element that is not a list of statements. * * @return the non-list child element */ protected DetailAST getNonListChild() { return getMainAst().findFirstToken(TokenTypes.RPAREN).getNextSibling(); }
/** * Checks if current if statement is single-line statement, e.g.: * <p> * {@code * if (obj.isValid()) return true; * } * </p> * @param literalIf {@link TokenTypes#LITERAL_IF if statement}. * @return true if current if statement is single-line statement. */ private static boolean isSingleLineIf(DetailAST literalIf) { boolean result = false; if (literalIf.getParent().getType() == TokenTypes.SLIST) { final DetailAST literalIfLastChild = literalIf.getLastChild(); final DetailAST block; if (literalIfLastChild.getType() == TokenTypes.LITERAL_ELSE) { block = literalIfLastChild.getPreviousSibling(); } else { block = literalIfLastChild; } final DetailAST ifCondition = literalIf.findFirstToken(TokenTypes.EXPR); result = ifCondition.getLineNo() == block.getLineNo(); } return result; }
/** * Checks that return type is {@code void}. * @param method the METHOD_DEF node * @return true if check passed, false otherwise */ private static boolean checkType(DetailAST method) { final DetailAST type = method.findFirstToken(TokenTypes.TYPE).getFirstChild(); return type.getType() == TokenTypes.LITERAL_VOID; }
@Override public void visitToken(DetailAST ast) { final DetailAST objBlock = ast.findFirstToken(TokenTypes.OBJBLOCK); final DetailAST methodDef = objBlock.findFirstToken(TokenTypes.METHOD_DEF); final DetailAST variableDef = objBlock.findFirstToken(TokenTypes.VARIABLE_DEF); final boolean methodRequired = !allowMarkerInterfaces || variableDef != null; if (methodDef == null && methodRequired) { log(ast.getLineNo(), MSG_KEY); } }