001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2018 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 212}