NoMainMethodInAbstractClassCheck.java

  1. ////////////////////////////////////////////////////////////////////////////////
  2. // checkstyle: Checks Java source code for adherence to a set of rules.
  3. // Copyright (C) 2001-2019 the original author or authors.
  4. //
  5. // This library is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU Lesser General Public
  7. // License as published by the Free Software Foundation; either
  8. // version 2.1 of the License, or (at your option) any later version.
  9. //
  10. // This library is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13. // Lesser General Public License for more details.
  14. //
  15. // You should have received a copy of the GNU Lesser General Public
  16. // License along with this library; if not, write to the Free Software
  17. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. ////////////////////////////////////////////////////////////////////////////////

  20. package com.github.sevntu.checkstyle.checks.design;

  22. import java.util.Deque;
  23. import java.util.LinkedList;

  25. import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
  26. import com.puppycrawl.tools.checkstyle.api.DetailAST;
  27. import com.puppycrawl.tools.checkstyle.api.TokenTypes;

  29. /**
  30.  * Forbids main methods in abstract classes. Existence of 'main' method can
  31.  * mislead a developer to consider this class as a ready-to-use implementation.
  32.  * @author Baratali Izmailov <a href="mailto:barataliba@gmail.com">email</a>
  33.  * @since 1.9.0
  34.  */
  35. public class NoMainMethodInAbstractClassCheck extends AbstractCheck {

  37.     /**
  38.      * Key for error message.
  39.      */
  40.     public static final String MSG_KEY = "avoid.main.method.in.abstract.class";

  42.     /** String representation of string class. */
  43.     private static final String STRING_CLASS = "String";

  45.     /**
  46.      * Keep OBJBLOCKs of classes that are under validation.
  47.      */
  48.     private final Deque<DetailAST> objBlockTokensStack =
  49.             new LinkedList<>();

  51.     @Override
  52.     public final int[] getDefaultTokens() {
  53.         return new int[] {
  54.             TokenTypes.CLASS_DEF,
  55.             TokenTypes.METHOD_DEF,
  56.         };
  57.     }

  59.     @Override
  60.     public int[] getAcceptableTokens() {
  61.         return getDefaultTokens();
  62.     }

  64.     @Override
  65.     public int[] getRequiredTokens() {
  66.         return getDefaultTokens();
  67.     }

  69.     @Override
  70.     public final void visitToken(final DetailAST ast) {
  71.         if (ast.getType() == TokenTypes.CLASS_DEF) {
  72.             if (isNotInnerClass(ast)) {
  73.                 // remove all tokens from stack
  74.                 objBlockTokensStack.clear();
  75.             }
  76.             if (hasAbstractModifier(ast)) {
  77.                 objBlockTokensStack.push(
  78.                         ast.findFirstToken(TokenTypes.OBJBLOCK));
  79.             }
  80.         }
  81.         // type of token is METHOD_DEF
  82.         else if (isChildOfCurrentObjBlockToken(ast) && isMainMethod(ast)) {
  83.             log(ast, MSG_KEY);
  84.             // remove current objblock
  85.             objBlockTokensStack.pop();
  86.         }
  87.     }

  89.     /**
  90.      * Verify that class is not inner.
  91.      * @param classDefAST
  92.      *        DetailAST of class definition.
  93.      * @return true if class is not inner, false otherwise.
  94.      */
  95.     private boolean isNotInnerClass(final DetailAST classDefAST) {
  96.         boolean result = true;
  97.         final DetailAST objBlockAST = classDefAST.getParent();
  98.         for (DetailAST currentObjBlock : objBlockTokensStack) {
  99.             if (objBlockAST == currentObjBlock) {
  100.                 result = false;
  101.                 break;
  102.             }
  103.         }
  104.         return result;
  105.     }

  107.     /**
  108.      * Verify that aMethodDefAST is child token of considered objblock.
  109.      * @param methodDefAST DetailAST of method definition.
  110.      * @return true if aMethodDefAST is child of of considered objblock.
  111.      */
  112.     private boolean isChildOfCurrentObjBlockToken(final DetailAST methodDefAST) {
  113.         final DetailAST objBlockAST = objBlockTokensStack.peek();
  114.         return objBlockAST != null
  115.                 && methodDefAST.getParent() == objBlockAST;
  116.     }

  118.     /**
  119.      * Return true if AST has abstract modifier.
  120.      * @param classDefAST
  121.      *        AST which has modifier
  122.      * @return true if AST has abstract modifier, false otherwise.
  123.      */
  124.     private static boolean hasAbstractModifier(final DetailAST classDefAST) {
  125.         final DetailAST modifiers =
  126.                 classDefAST.findFirstToken(TokenTypes.MODIFIERS);
  127.         return hasChildToken(modifiers, TokenTypes.ABSTRACT);
  128.     }

  130.     /**
  131.      * Verifies that the given DetailAST is a main method.
  132.      * @param methodAST
  133.      *        DetailAST instance.
  134.      * @return true if aMethodAST is a main method, false otherwise.
  135.      */
  136.     private static boolean isMainMethod(final DetailAST methodAST) {
  137.         boolean result = true;
  138.         final String methodName = getIdentifier(methodAST);
  139.         if ("main".equals(methodName)) {
  140.             result = isVoidType(methodAST)
  141.                     && isMainMethodModifiers(methodAST)
  142.                     && isMainMethodParameters(methodAST);
  143.         }
  144.         else {
  145.             result = false;
  146.         }
  147.         return result;
  148.     }

  150.     /**
  151.      * Get identifier of AST. These can be names of types, subpackages,
  152.      * fields, methods, parameters, and local variables.
  153.      * @param ast
  154.      *        DetailAST instance
  155.      * @return identifier of AST, null if AST does not have name.
  156.      */
  157.     private static String getIdentifier(final DetailAST ast) {
  158.         final DetailAST ident = ast.findFirstToken(TokenTypes.IDENT);
  159.         return ident.getText();
  160.     }

  162.     /**
  163.      * Verifies that given AST has appropriate modifiers for main method.
  164.      * @param methodAST
  165.      *        DetailAST instance.
  166.      * @return true if aMethodAST has (public & static & !abstract) modifiers,
  167.      *         false otherwise.
  168.      */
  169.     private static boolean isMainMethodModifiers(final DetailAST methodAST) {
  170.         final DetailAST modifiers =
  171.                 methodAST.findFirstToken(TokenTypes.MODIFIERS);
  172.         return hasChildToken(modifiers, TokenTypes.LITERAL_PUBLIC)
  173.                 && hasChildToken(modifiers, TokenTypes.LITERAL_STATIC);
  174.     }

  176.     /**
  177.      * Verifies that given AST has type and this type is void.
  178.      * @param methodAST
  179.      *        DetailAST instance.
  180.      * @return true if AST's type void, false otherwise.
  181.      */
  182.     private static boolean isVoidType(final DetailAST methodAST) {
  183.         final DetailAST methodTypeAST = methodAST.findFirstToken(TokenTypes.TYPE);
  184.         return hasChildToken(methodTypeAST, TokenTypes.LITERAL_VOID);
  185.     }

  187.     /**
  188.      * Verifies that given AST has appropriate for main method parameters.
  189.      * @param methodAST
  190.      *        instance of a method
  191.      * @return true if parameters of aMethodAST are appropriate for main method,
  192.      *         false otherwise.
  193.      */
  194.     private static boolean isMainMethodParameters(final DetailAST methodAST) {
  195.         final DetailAST params =
  196.                 methodAST.findFirstToken(TokenTypes.PARAMETERS);
  197.         return hasOnlyStringArrayParameter(params)
  198.                 || hasOnlyStringEllipsisParameter(params);
  199.     }

  201.     /**
  202.      * Return true if AST of method parameters has String[] parameter child
  203.      * token.
  204.      * @param parametersAST
  205.      *        DetailAST of method parameters.
  206.      * @return true if AST has String[] parameter child token, false otherwise.
  207.      */
  208.     private static boolean hasOnlyStringArrayParameter(final DetailAST parametersAST) {
  209.         boolean result = true;
  210.         if (parametersAST.getChildCount(TokenTypes.PARAMETER_DEF) == 1) {
  211.             final DetailAST parameterDefinitionAST =
  212.                     parametersAST.findFirstToken(TokenTypes.PARAMETER_DEF);
  213.             final DetailAST parameterTypeAST = parameterDefinitionAST
  214.                     .findFirstToken(TokenTypes.TYPE);
  215.             if (hasChildToken(parameterTypeAST, TokenTypes.ARRAY_DECLARATOR)) {
  216.                 final DetailAST arrayDeclaratorAST = parameterTypeAST
  217.                         .findFirstToken(TokenTypes.ARRAY_DECLARATOR);
  218.                 final String parameterName =
  219.                         getIdentifier(arrayDeclaratorAST);
  220.                 result = STRING_CLASS.equals(parameterName);
  221.             }
  222.             else {
  223.                 result = false;
  224.             }
  225.         }
  226.         else {
  227.             // there is none or multiple parameters
  228.             result = false;
  229.         }
  230.         return result;
  231.     }

  233.     /**
  234.      * Return true if AST of method parameters has String... parameter child
  235.      * token.
  236.      * @param parametersAST
  237.      *        DetailAST of method parameters.
  238.      * @return true if aParametersAST has String... parameter child token, false
  239.      *         otherwise.
  240.      */
  241.     private static boolean hasOnlyStringEllipsisParameter(final DetailAST parametersAST) {
  242.         boolean result = true;
  243.         if (parametersAST.getChildCount(TokenTypes.PARAMETER_DEF) == 1) {
  244.             final DetailAST parameterDefinitionAST =
  245.                     parametersAST.findFirstToken(TokenTypes.PARAMETER_DEF);
  246.             if (hasChildToken(parameterDefinitionAST, TokenTypes.ELLIPSIS)) {
  247.                 final DetailAST parameterTypeAST =
  248.                         parameterDefinitionAST.findFirstToken(TokenTypes.TYPE);
  249.                 final String parameterName =
  250.                         getIdentifier(parameterTypeAST);
  251.                 result = STRING_CLASS.equals(parameterName);
  252.             }
  253.             else {
  254.                 result = false;
  255.             }
  256.         }
  257.         else {
  258.             // there is none or multiple parameters
  259.             result = false;
  260.         }
  261.         return result;
  262.     }

  264.     /**
  265.      * Return true if aAST has token of aTokenType type.
  266.      * @param ast
  267.      *        DetailAST instance.
  268.      * @param tokenType
  269.      *        one of TokenTypes
  270.      * @return true if aAST has token of given type, or false otherwise.
  271.      */
  272.     private static boolean hasChildToken(DetailAST ast, int tokenType) {
  273.         return ast.findFirstToken(tokenType) != null;
  274.     }

  276. }
Created with JaCoCo 0.7.1.201405082137