Index: src/testinputs/com/puppycrawl/tools/checkstyle/coding/InputAvoidNotShortCircuitOperatorsForBooleanCheck.java
===================================================================
--- src/testinputs/com/puppycrawl/tools/checkstyle/coding/InputAvoidNotShortCircuitOperatorsForBooleanCheck.java (revision 0)
+++ src/testinputs/com/puppycrawl/tools/checkstyle/coding/InputAvoidNotShortCircuitOperatorsForBooleanCheck.java (revision 0)
@@ -0,0 +1,129 @@
+package com.puppycrawl.tools.checkstyle.coding;
+
+public class InputAvoidNotShortCircuitOperatorsForBooleanCheck {
+public static boolean x;
+public boolean y, z;
+boolean result=x|y||z; // !
+
+ public void main(){
+
+ boolean res1=x|y||z; //
+ int res2 = 4|56;
+ if(x|y||z){ //
+ int kkk=5;
+ }
+
+ x|=x&&y||z; //
+ x=x&y||z; //
+
+ x |= isFalse();
+ x = isFalse() | isFalse() & isTrue();
+
+ }
+
+ boolean isTrue() {
+ return true|false; // !
+ //boolean res1=x|y||z; //
+ }
+
+ public int doSomething() {
+ return (5|6); //
+ }
+
+ boolean isFalse() {
+ boolean i=false;
+ for(int x=0; x<6|i; x|=5){ // !
+ int k=0;
+ }
+ int k=6;
+ int y=6;
+ while((k&y) > 7){ //
+ int h=0;
+ }
+ return false;
+ }
+
+ boolean isGood() {
+ boolean i=true;
+ for(int x=0; x<6|i; x|=5){ // !
+ int k=0;
+ }
+ boolean k=true;
+ boolean y=false;
+ while(k&y){ // !
+ int h=0;
+ }
+ return false;
+ }
+
+ boolean testAnotherSituations() {
+
+ boolean a = !x
+ || x()
+ || y()
+ | (this.z // ! (because true/false is here)
+ || InputAvoidNotShortCircuitOperatorsForBooleanCheck.x)
+ && true || false;
+
+ a = !x
+ || x()
+ || y()
+ | (this.z // ! (because a is already defined boolean variable)
+ || InputAvoidNotShortCircuitOperatorsForBooleanCheck.x);
+
+ boolean IsThere=false;
+
+ boolean r = !IsThere
+ || x()
+ || y()
+ | (this.z // ! (because IsThere is a boolean variable)
+ || InputAvoidNotShortCircuitOperatorsForBooleanCheck.x);
+
+ boolean new1 = !x
+ || x()
+ || y()
+ | (this.z //
+ || InputAvoidNotShortCircuitOperatorsForBooleanCheck.x);
+
+ return a|a; // !
+
+ }
+
+ public void check() {
+
+ boolean f = x|true; // !
+ f = x|false; // !
+ f = x|y; // !
+ f |= this.z; // !
+
+ boolean m = x|z; //
+ boolean m1 = x|y; //
+ x |= this.z; //
+ while(x|y){} //
+ boolean x=true;
+ y |= InputAvoidNotShortCircuitOperatorsForBooleanCheck.x; //
+
+ y |= getMessage(x);
+
+
+ }
+
+ public boolean x() {
+ int x;
+ return true; }
+
+ public boolean y() {
+ return true;
+ }
+
+ public boolean getMessage(boolean from) {
+ return true;
+ }
+
+ public void doSomethingElse() {
+ //int x;
+ while (x | y) {
+ }
+ }
+
+}
\ No newline at end of file
Index: src/tests/com/puppycrawl/tools/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheckTest.java
===================================================================
--- src/tests/com/puppycrawl/tools/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheckTest.java (revision 0)
+++ src/tests/com/puppycrawl/tools/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheckTest.java (revision 0)
@@ -0,0 +1,41 @@
+package com.puppycrawl.tools.checkstyle.checks.coding;
+
+import com.puppycrawl.tools.checkstyle.BaseCheckTestSupport;
+import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
+import java.io.File;
+import org.junit.Test;
+
+public class AvoidNotShortCircuitOperatorsForBooleanCheckTest extends BaseCheckTestSupport {
+
+
+ @Test
+ public final void testAll() throws Exception {
+ DefaultConfiguration checkConfig = createCheckConfig(AvoidNotShortCircuitOperatorsForBooleanCheck.class);
+
+ String[] expected = {
+ "6:17: "+createMsg("|"),
+ "25:20: "+createMsg("|"),
+ "35:25: "+createMsg("|"),
+ "48:25: "+createMsg("|"),
+ "53:16: "+createMsg("&"),
+
+ "64:17: "+createMsg("|"),
+ "71:9: "+createMsg("|"),
+ "79:9: "+createMsg("|"),
+ "88:17: "+createMsg("|"),
+
+ "94:22: "+createMsg("|"),
+ "95:14: "+createMsg("|"),
+ "96:14: "+createMsg("|"),
+ "97:11: "+createMsg("|="),
+
+ };
+
+ verify(checkConfig, getPath("coding" + File.separator + "InputAvoidNotShortCircuitOperatorsForBooleanCheck.java"), expected);
+ }
+
+ public String createMsg(String literal){
+ return "Not short-circuit Operator '" + literal + "' used.";
+ }
+
+}
Index: src/checkstyle/com/puppycrawl/tools/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheck.java
===================================================================
--- src/checkstyle/com/puppycrawl/tools/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheck.java (revision 0)
+++ src/checkstyle/com/puppycrawl/tools/checkstyle/checks/coding/AvoidNotShortCircuitOperatorsForBooleanCheck.java (revision 0)
@@ -0,0 +1,292 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2010 Oliver Burn
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+////////////////////////////////////////////////////////////////////////////////
+package com.puppycrawl.tools.checkstyle.checks.coding;
+
+import java.util.LinkedList;
+
+import com.puppycrawl.tools.checkstyle.api.DetailAST;
+import com.puppycrawl.tools.checkstyle.api.TokenTypes;
+import com.puppycrawl.tools.checkstyle.api.Check;
+import com.puppycrawl.tools.checkstyle.checks.CheckUtils;
+
+/**
+ *
+ * This check limits using of not short-circuit operators
+ * ("|", "&", "|=", "&=") in boolean expressions.
+ *
+ * Reason:
+ * Short-circuit operators ("||", "&&") are more
+ * safer and can accelerate the evaluation of complex boolean expressions.
+ * Check identifies an expression as a boolean if it contains at least one
+ * boolean operand or if result of expression evaluation sets the value of a
+ * boolean variable.
+ *
Using boolean variables that do not belong
+ * to the current class and all calls to boolean methods are not handled by
+ * this check.
Examples:
+ *
+ *
+ * - Using of not short-circuit operators while determining a Boolean variable
+ *
+ *
+ * boolean x = true;
+ * boolean result = true | x || false; // a warning here
+ *
+ *
+ * - Using of not short-circuit operators while overriding a Boolean variable.
+ *
+ *
+ * boolean x = true;
+ * boolean result = false;
+ * // any code
+ * result &= true | x || false; // a warning here
+ *
+ *
+ * - Expression calculated with not short-circuit operators contains at least
+ * one boolean operand.
+ *
+ *
+ * public boolean isTrue() {
+ * return this.z | MyObject.is() // no warnings here
+ * || isModifier() && isNotTrue();
+ * }
+ * ...
+ * boolean r=true;
+ * public boolean isTrue() {
+ * return this.z | true && r // a warning here
+ * || isModifier() && isNotTrue();
+ * }
+ *
+ *
+ *
+ * @author Daniil
+ * Yaroslavtsev
+ */
+public class AvoidNotShortCircuitOperatorsForBooleanCheck extends Check
+{
+
+ /**
+ * A "boolean" String.
+ * */
+ private final String mBOOLEAN = "boolean";
+
+ /**
+ * A key to search the warning message text in "messages.properties" file.
+ * */
+ private final String mKey = "avoid.not.short.circuit.operators.for.boolean";
+
+ /**
+ * A list contains all names of operands, which are used in the current
+ * expression, which calculates with using "|", "&", "|=", "&=" operators.
+ * */
+ private final LinkedList mSupportedOperands =
+ new LinkedList();
+
+ /**
+ * Variable, that indicates keywords "true" or "false" in current
+ * expression.
+ * */
+ private boolean mHasTrueOrFalseLiteral;
+
+ @Override
+ public final int[] getDefaultTokens()
+ {
+ return new int[] {TokenTypes.BOR, TokenTypes.BAND,
+ TokenTypes.BOR_ASSIGN, TokenTypes.BAND_ASSIGN, };
+ }
+
+ @Override
+ public final void visitToken(final DetailAST aDetailAST)
+ {
+
+ DetailAST currentNode = aDetailAST;
+ while (currentNode != null
+ && currentNode.getType() != TokenTypes.EXPR
+ && currentNode.getType() != TokenTypes.METHOD_DEF
+ && currentNode.getType() != TokenTypes.CTOR_DEF
+ && currentNode.getType() != TokenTypes.CLASS_DEF)
+ {
+ currentNode = currentNode.getParent();
+ }
+
+ final int type = currentNode.getType();
+
+ if (type == TokenTypes.EXPR) {
+
+ if (isBooleanExpression(currentNode)) {
+ log(aDetailAST, mKey, aDetailAST.getText());
+ }
+
+ mSupportedOperands.clear();
+ mHasTrueOrFalseLiteral = false;
+ }
+
+ }
+
+ /**
+ * Checks whether the current method/variable definition type
+ * is "Boolean".
+ * @param aNode - current method or variable definition node.
+ * @return "true" if current method or variable has a Boolean type.
+ */
+ public final boolean isBooleanType(final DetailAST aNode)
+ {
+ return mBOOLEAN.equals(CheckUtils.createFullType(
+ aNode.findFirstToken(TokenTypes.TYPE)).getText());
+ }
+
+ /**
+ * Checks that current expression is calculated using "|", "&", "|=", "&="
+ * operators contains at least one Boolean operand.
+ * @param aNode - current TokenTypes.EXPR node to check.
+ * @return "true" if current expression is calculated using "|", "&",
+ * "|=". "&=" operators contains at least one Boolean operand or false
+ * otherwise.
+ */
+ public final boolean isBooleanExpression(final DetailAST aNode)
+ {
+
+ DetailAST curNode = aNode;
+
+ final LinkedList childNames =
+ getSupportedOperandsNames(curNode);
+ final LinkedList booleanVariablesNames =
+ new LinkedList();
+
+ while (curNode != null
+ && curNode.getType() != TokenTypes.CTOR_DEF
+ && curNode.getType() != TokenTypes.METHOD_DEF
+ && curNode.getType() != TokenTypes.CLASS_DEF)
+ {
+ curNode = curNode.getParent();
+ }
+
+ final int line = aNode.getLineNo();
+ for (DetailAST currentNode : getChildren(curNode.getLastChild())) {
+ if (currentNode.getLineNo() < line
+ && currentNode.getType() == TokenTypes.VARIABLE_DEF)
+ {
+
+ if (isBooleanType(currentNode)) {
+ booleanVariablesNames.add(currentNode.findFirstToken(
+ TokenTypes.IDENT).getText());
+ }
+ }
+ }
+
+ boolean result = false;
+
+ for (String name : childNames) {
+ if (booleanVariablesNames.contains(name)) {
+ result = true;
+ break;
+ }
+ }
+ result = result || hasTrueOrFalseLiteral(aNode);
+ return result;
+ }
+
+ /** Searches for all supported operands names in current expression.
+ * When checking, treatments to external class variables, method calls,
+ * etc are not considered as expression operands.
+ * @param aEXPRParentAST - the current TokenTypes.EXPR parent node.
+ * @return List of supported operands contained in current expression.
+ */
+ public final LinkedList getSupportedOperandsNames(
+ final DetailAST aEXPRParentAST)
+ {
+
+ for (DetailAST currentNode : getChildren(aEXPRParentAST)) {
+
+ if (currentNode.getNumberOfChildren() > 0
+ && currentNode.getType() != TokenTypes.METHOD_CALL)
+ {
+ getSupportedOperandsNames(currentNode);
+ }
+
+ if (currentNode.getType() == TokenTypes.IDENT
+ && currentNode.getParent() != null
+ && currentNode.getParent().getType() != TokenTypes.DOT)
+ {
+ mSupportedOperands.add(currentNode.getText());
+ }
+
+ if (currentNode.getNextSibling() != null) {
+ currentNode = currentNode.getNextSibling();
+ }
+ }
+ return mSupportedOperands;
+ }
+
+
+ /**
+ * Checks is the current expression has
+ * keywords "true" or "false".
+ * @param aParentAST - the current TokenTypes.EXPR parent node.
+ * @return true if the current processed expression contains
+ * "true" or "false" keywords and false otherwise.
+ */
+ public final boolean hasTrueOrFalseLiteral(final DetailAST aParentAST)
+ {
+
+ for (DetailAST currentNode : getChildren(aParentAST)) {
+
+ if (currentNode.getNumberOfChildren() > 0) {
+ hasTrueOrFalseLiteral(currentNode);
+ }
+
+ final int type = currentNode.getType();
+ if (type == TokenTypes.LITERAL_TRUE
+ || type == TokenTypes.LITERAL_FALSE)
+ {
+ mHasTrueOrFalseLiteral = true;
+ }
+
+ if (currentNode.getNextSibling() != null) {
+ currentNode = currentNode.getNextSibling();
+ }
+
+ if (mHasTrueOrFalseLiteral) {
+ break;
+ }
+ }
+ return mHasTrueOrFalseLiteral;
+ }
+
+ /**
+ * Gets all the children one level below on the current top node.
+ * @param aNode - current parent node.
+ * @return an array of children one level below on the current parent node
+ * aNode.
+ */
+ public final LinkedList getChildren(final DetailAST aNode)
+ {
+ final LinkedList result = new LinkedList();
+
+ DetailAST currNode = aNode.getFirstChild();
+
+ while (currNode != null) {
+ result.add(currNode);
+ currNode = currNode.getNextSibling();
+ }
+
+ return result;
+ }
+
+}
+
Index: src/checkstyle/com/puppycrawl/tools/checkstyle/checks/coding/messages.properties
===================================================================
--- src/checkstyle/com/puppycrawl/tools/checkstyle/checks/coding/messages.properties (revision 2587)
+++ src/checkstyle/com/puppycrawl/tools/checkstyle/checks/coding/messages.properties (working copy)
@@ -2,6 +2,7 @@
assignment.inner.avoid=Inner assignments should be avoided.
avoid.finalizer.method=Avoid using finalizer method.
avoid.clone.method=Avoid using clone method.
+avoid.not.short.circuit.operators.for.boolean=Not short-circuit Operator ''{0}'' used.
covariant.equals=covariant equals without overriding equals(java.lang.Object).
declaration.order.constructor=Constructor definition in wrong order.
declaration.order.method=Method definition in wrong order.