001////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code for adherence to a set of rules.
003// Copyright (C) 2001-2017 the original author or authors.
004//
005// This library is free software; you can redistribute it and/or
006// modify it under the terms of the GNU Lesser General Public
007// License as published by the Free Software Foundation; either
008// version 2.1 of the License, or (at your option) any later version.
009//
010// This library is distributed in the hope that it will be useful,
011// but WITHOUT ANY WARRANTY; without even the implied warranty of
012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
013// Lesser General Public License for more details.
014//
015// You should have received a copy of the GNU Lesser General Public
016// License along with this library; if not, write to the Free Software
017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
018////////////////////////////////////////////////////////////////////////////////
019
020package com.puppycrawl.tools.checkstyle.checks.coding;
021
022import com.puppycrawl.tools.checkstyle.StatelessCheck;
023import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
024import com.puppycrawl.tools.checkstyle.api.DetailAST;
025import com.puppycrawl.tools.checkstyle.api.TokenTypes;
026import com.puppycrawl.tools.checkstyle.utils.CheckUtils;
027import com.puppycrawl.tools.checkstyle.utils.ScopeUtils;
028
029/**
030 * <p>
031 * Checks if any class or object member explicitly initialized
032 * to default for its type value ({@code null} for object
033 * references, zero for numeric types and {@code char}
034 * and {@code false} for {@code boolean}.
035 * </p>
036 * <p>
037 * Rationale: each instance variable gets
038 * initialized twice, to the same value.  Java
039 * initializes each instance variable to its default
040 * value (0 or null) before performing any
041 * initialization specified in the code.  So in this case,
042 * x gets initialized to 0 twice, and bar gets initialized
043 * to null twice.  So there is a minor inefficiency.  This style of
044 * coding is a hold-over from C/C++ style coding,
045 * and it shows that the developer isn't really confident that
046 * Java really initializes instance variables to default
047 * values.
048 * </p>
049 *
050 * @author o_sukhodolsky
051 */
052@StatelessCheck
053public class ExplicitInitializationCheck extends AbstractCheck {
054
055    /**
056     * A key is pointing to the warning message text in "messages.properties"
057     * file.
058     */
059    public static final String MSG_KEY = "explicit.init";
060
061    /** Whether only explicit initialization made to null should be checked.**/
062    private boolean onlyObjectReferences;
063
064    @Override
065    public final int[] getDefaultTokens() {
066        return getRequiredTokens();
067    }
068
069    @Override
070    public final int[] getRequiredTokens() {
071        return new int[] {TokenTypes.VARIABLE_DEF};
072    }
073
074    @Override
075    public final int[] getAcceptableTokens() {
076        return getRequiredTokens();
077    }
078
079    /**
080     * Sets whether only explicit initialization made to null should be checked.
081     * @param onlyObjectReferences whether only explicit initialization made to null
082     *                             should be checked
083     */
084    public void setOnlyObjectReferences(boolean onlyObjectReferences) {
085        this.onlyObjectReferences = onlyObjectReferences;
086    }
087
088    @Override
089    public void visitToken(DetailAST ast) {
090        if (!isSkipCase(ast)) {
091            final DetailAST assign = ast.findFirstToken(TokenTypes.ASSIGN);
092            final DetailAST exprStart =
093                assign.getFirstChild().getFirstChild();
094            final DetailAST type = ast.findFirstToken(TokenTypes.TYPE);
095            if (isObjectType(type)
096                && exprStart.getType() == TokenTypes.LITERAL_NULL) {
097                final DetailAST ident = ast.findFirstToken(TokenTypes.IDENT);
098                log(ident, MSG_KEY, ident.getText(), "null");
099            }
100            if (!onlyObjectReferences) {
101                validateNonObjects(ast);
102            }
103        }
104    }
105
106    /**
107     * Checks for explicit initializations made to 'false', '0' and '\0'.
108     * @param ast token being checked for explicit initializations
109     */
110    private void validateNonObjects(DetailAST ast) {
111        final DetailAST ident = ast.findFirstToken(TokenTypes.IDENT);
112        final DetailAST assign = ast.findFirstToken(TokenTypes.ASSIGN);
113        final DetailAST exprStart =
114                assign.getFirstChild().getFirstChild();
115        final DetailAST type = ast.findFirstToken(TokenTypes.TYPE);
116        final int primitiveType = type.getFirstChild().getType();
117        if (primitiveType == TokenTypes.LITERAL_BOOLEAN
118                && exprStart.getType() == TokenTypes.LITERAL_FALSE) {
119            log(ident, MSG_KEY, ident.getText(), "false");
120        }
121        if (isNumericType(primitiveType) && isZero(exprStart)) {
122            log(ident, MSG_KEY, ident.getText(), "0");
123        }
124        if (primitiveType == TokenTypes.LITERAL_CHAR
125                && isZeroChar(exprStart)) {
126            log(ident, MSG_KEY, ident.getText(), "\\0");
127        }
128    }
129
130    /**
131     * Examine char literal for initializing to default value.
132     * @param exprStart expression
133     * @return true is literal is initialized by zero symbol
134     */
135    private static boolean isZeroChar(DetailAST exprStart) {
136        return isZero(exprStart)
137            || exprStart.getType() == TokenTypes.CHAR_LITERAL
138            && "'\\0'".equals(exprStart.getText());
139    }
140
141    /**
142     * Checks for cases that should be skipped: no assignment, local variable, final variables.
143     * @param ast Variable def AST
144     * @return true is that is a case that need to be skipped.
145     */
146    private static boolean isSkipCase(DetailAST ast) {
147        boolean skipCase = true;
148
149        // do not check local variables and
150        // fields declared in interface/annotations
151        if (!ScopeUtils.isLocalVariableDef(ast)
152                && !ScopeUtils.isInInterfaceOrAnnotationBlock(ast)) {
153            final DetailAST assign = ast.findFirstToken(TokenTypes.ASSIGN);
154
155            if (assign != null) {
156                final DetailAST modifiers = ast.findFirstToken(TokenTypes.MODIFIERS);
157                skipCase = modifiers.findFirstToken(TokenTypes.FINAL) != null;
158            }
159        }
160        return skipCase;
161    }
162
163    /**
164     * Determines if a given type is an object type.
165     * @param type type to check.
166     * @return true if it is an object type.
167     */
168    private static boolean isObjectType(DetailAST type) {
169        final int objectType = type.getFirstChild().getType();
170        return objectType == TokenTypes.IDENT || objectType == TokenTypes.DOT
171                || objectType == TokenTypes.ARRAY_DECLARATOR;
172    }
173
174    /**
175     * Determine if a given type is a numeric type.
176     * @param type code of the type for check.
177     * @return true if it's a numeric type.
178     * @see TokenTypes
179     */
180    private static boolean isNumericType(int type) {
181        return type == TokenTypes.LITERAL_BYTE
182                || type == TokenTypes.LITERAL_SHORT
183                || type == TokenTypes.LITERAL_INT
184                || type == TokenTypes.LITERAL_FLOAT
185                || type == TokenTypes.LITERAL_LONG
186                || type == TokenTypes.LITERAL_DOUBLE;
187    }
188
189    /**
190     * Checks if given node contains numeric constant for zero.
191     *
192     * @param expr node to check.
193     * @return true if given node contains numeric constant for zero.
194     */
195    private static boolean isZero(DetailAST expr) {
196        final int type = expr.getType();
197        final boolean isZero;
198        switch (type) {
199            case TokenTypes.NUM_FLOAT:
200            case TokenTypes.NUM_DOUBLE:
201            case TokenTypes.NUM_INT:
202            case TokenTypes.NUM_LONG:
203                final String text = expr.getText();
204                isZero = Double.compare(CheckUtils.parseDouble(text, type), 0.0) == 0;
205                break;
206            default:
207                isZero = false;
208        }
209        return isZero;
210    }
211}