| /* |
| * Copyright (c) 2013, the Dart project authors. |
| * |
| * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.dart.engine.internal.hint; |
| |
| import com.google.dart.engine.ast.AstNode; |
| import com.google.dart.engine.ast.BinaryExpression; |
| import com.google.dart.engine.ast.Block; |
| import com.google.dart.engine.ast.BooleanLiteral; |
| import com.google.dart.engine.ast.BreakStatement; |
| import com.google.dart.engine.ast.CatchClause; |
| import com.google.dart.engine.ast.ConditionalExpression; |
| import com.google.dart.engine.ast.ContinueStatement; |
| import com.google.dart.engine.ast.Expression; |
| import com.google.dart.engine.ast.Identifier; |
| import com.google.dart.engine.ast.IfStatement; |
| import com.google.dart.engine.ast.NodeList; |
| import com.google.dart.engine.ast.PropertyAccess; |
| import com.google.dart.engine.ast.ReturnStatement; |
| import com.google.dart.engine.ast.Statement; |
| import com.google.dart.engine.ast.SwitchCase; |
| import com.google.dart.engine.ast.SwitchDefault; |
| import com.google.dart.engine.ast.SwitchMember; |
| import com.google.dart.engine.ast.TryStatement; |
| import com.google.dart.engine.ast.TypeName; |
| import com.google.dart.engine.ast.WhileStatement; |
| import com.google.dart.engine.ast.visitor.RecursiveAstVisitor; |
| import com.google.dart.engine.element.Element; |
| import com.google.dart.engine.element.PropertyAccessorElement; |
| import com.google.dart.engine.element.PropertyInducingElement; |
| import com.google.dart.engine.error.HintCode; |
| import com.google.dart.engine.internal.constant.EvaluationResultImpl; |
| import com.google.dart.engine.internal.error.ErrorReporter; |
| import com.google.dart.engine.internal.object.BoolState; |
| import com.google.dart.engine.internal.object.DartObjectImpl; |
| import com.google.dart.engine.scanner.Token; |
| import com.google.dart.engine.scanner.TokenType; |
| import com.google.dart.engine.type.Type; |
| |
| import java.util.ArrayList; |
| |
| /** |
| * Instances of the class {@code DeadCodeVerifier} traverse an AST structure looking for cases of |
| * {@link HintCode#DEAD_CODE}. |
| * |
| * @coverage dart.engine.resolver |
| */ |
| public class DeadCodeVerifier extends RecursiveAstVisitor<Void> { |
| |
| /** |
| * The error reporter by which errors will be reported. |
| */ |
| private ErrorReporter errorReporter; |
| |
| /** |
| * Create a new instance of the {@link DeadCodeVerifier}. |
| * |
| * @param errorReporter the error reporter |
| */ |
| public DeadCodeVerifier(ErrorReporter errorReporter) { |
| this.errorReporter = errorReporter; |
| } |
| |
| @Override |
| public Void visitBinaryExpression(BinaryExpression node) { |
| Token operator = node.getOperator(); |
| boolean isAmpAmp = operator.getType() == TokenType.AMPERSAND_AMPERSAND; |
| boolean isBarBar = operator.getType() == TokenType.BAR_BAR; |
| if (isAmpAmp || isBarBar) { |
| Expression lhsCondition = node.getLeftOperand(); |
| if (!isDebugConstant(lhsCondition)) { |
| EvaluationResultImpl lhsResult = getConstantBooleanValue(lhsCondition); |
| if (lhsResult != null) { |
| if (lhsResult.getValue().isTrue() && isBarBar) { |
| // report error on else block: true || !e! |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.getRightOperand()); |
| // only visit the LHS: |
| safelyVisit(lhsCondition); |
| return null; |
| } else if (lhsResult.getValue().isFalse() && isAmpAmp) { |
| // report error on if block: false && !e! |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.getRightOperand()); |
| // only visit the LHS: |
| safelyVisit(lhsCondition); |
| return null; |
| } |
| } |
| } |
| // How do we want to handle the RHS? It isn't dead code, but "pointless" or "obscure"... |
| // Expression rhsCondition = node.getRightOperand(); |
| // ValidResult rhsResult = getConstantBooleanValue(rhsCondition); |
| // if (rhsResult != null) { |
| // if (rhsResult == ValidResult.RESULT_TRUE && isBarBar) { |
| // // report error on else block: !e! || true |
| // errorReporter.reportError(HintCode.DEAD_CODE, node.getRightOperand()); |
| // // only visit the RHS: |
| // safelyVisit(rhsCondition); |
| // return null; |
| // } else if (rhsResult == ValidResult.RESULT_FALSE && isAmpAmp) { |
| // // report error on if block: !e! && false |
| // errorReporter.reportError(HintCode.DEAD_CODE, node.getRightOperand()); |
| // // only visit the RHS: |
| // safelyVisit(rhsCondition); |
| // return null; |
| // } |
| // } |
| } |
| return super.visitBinaryExpression(node); |
| } |
| |
| /** |
| * For each {@link Block}, this method reports and error on all statements between the end of the |
| * block and the first return statement (assuming there it is not at the end of the block.) |
| * |
| * @param node the block to evaluate |
| */ |
| @Override |
| public Void visitBlock(Block node) { |
| NodeList<Statement> statements = node.getStatements(); |
| checkForDeadStatementsInNodeList(statements); |
| return null; |
| } |
| |
| @Override |
| public Void visitConditionalExpression(ConditionalExpression node) { |
| Expression conditionExpression = node.getCondition(); |
| safelyVisit(conditionExpression); |
| if (!isDebugConstant(conditionExpression)) { |
| EvaluationResultImpl result = getConstantBooleanValue(conditionExpression); |
| if (result != null) { |
| if (result.getValue().isTrue()) { |
| // report error on else block: true ? 1 : !2! |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.getElseExpression()); |
| safelyVisit(node.getThenExpression()); |
| return null; |
| } else { |
| // report error on if block: false ? !1! : 2 |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.getThenExpression()); |
| safelyVisit(node.getElseExpression()); |
| return null; |
| } |
| } |
| } |
| return super.visitConditionalExpression(node); |
| } |
| |
| @Override |
| public Void visitIfStatement(IfStatement node) { |
| Expression conditionExpression = node.getCondition(); |
| safelyVisit(conditionExpression); |
| if (!isDebugConstant(conditionExpression)) { |
| EvaluationResultImpl result = getConstantBooleanValue(conditionExpression); |
| if (result != null) { |
| if (result.getValue().isTrue()) { |
| // report error on else block: if(true) {} else {!} |
| Statement elseStatement = node.getElseStatement(); |
| if (elseStatement != null) { |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, elseStatement); |
| safelyVisit(node.getThenStatement()); |
| return null; |
| } |
| } else { |
| // report error on if block: if (false) {!} else {} |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.getThenStatement()); |
| safelyVisit(node.getElseStatement()); |
| return null; |
| } |
| } |
| } |
| return super.visitIfStatement(node); |
| } |
| |
| // Do we want to report "pointless" or "obscure" code such as do {} !while (false);! |
| //@Override |
| //public Void visitDoStatement(DoStatement node) { |
| // Expression conditionExpression = node.getCondition(); |
| // ValidResult result = getConstantBooleanValue(conditionExpression); |
| // if (result != null) { |
| // if (result == ValidResult.RESULT_FALSE) { |
| // // report error on if block: do {} !while (false);! |
| // int whileOffset = node.getWhileKeyword().getOffset(); |
| // int semiColonOffset = node.getSemicolon().getOffset() + 1; |
| // int length = semiColonOffset - whileOffset; |
| // errorReporter.reportError(HintCode.DEAD_CODE, whileOffset, length); |
| // } |
| // } |
| // return super.visitDoStatement(node); |
| //} |
| |
| @Override |
| public Void visitSwitchCase(SwitchCase node) { |
| checkForDeadStatementsInNodeList(node.getStatements()); |
| return super.visitSwitchCase(node); |
| } |
| |
| @Override |
| public Void visitSwitchDefault(SwitchDefault node) { |
| checkForDeadStatementsInNodeList(node.getStatements()); |
| return super.visitSwitchDefault(node); |
| } |
| |
| @Override |
| public Void visitTryStatement(TryStatement node) { |
| safelyVisit(node.getBody()); |
| safelyVisit(node.getFinallyBlock()); |
| NodeList<CatchClause> catchClauses = node.getCatchClauses(); |
| int numOfCatchClauses = catchClauses.size(); |
| ArrayList<Type> visitedTypes = new ArrayList<Type>(numOfCatchClauses); |
| for (int i = 0; i < numOfCatchClauses; i++) { |
| CatchClause catchClause = catchClauses.get(i); |
| if (catchClause.getOnKeyword() != null) { |
| // on-catch clause found, verify that the exception type is not a subtype of a previous |
| // on-catch exception type |
| TypeName typeName = catchClause.getExceptionType(); |
| if (typeName != null && typeName.getType() != null) { |
| Type currentType = typeName.getType(); |
| if (currentType.isObject()) { |
| // Found catch clause clause that has Object as an exception type, this is equivalent to |
| // having a catch clause that doesn't have an exception type, visit the block, but |
| // generate an error on any following catch clauses (and don't visit them). |
| safelyVisit(catchClause); |
| if (i + 1 != numOfCatchClauses) { |
| // this catch clause is not the last in the try statement |
| CatchClause nextCatchClause = catchClauses.get(i + 1); |
| CatchClause lastCatchClause = catchClauses.get(numOfCatchClauses - 1); |
| int offset = nextCatchClause.getOffset(); |
| int length = lastCatchClause.getEnd() - offset; |
| errorReporter.reportErrorForOffset( |
| HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, |
| offset, |
| length); |
| return null; |
| } |
| } |
| for (Type type : visitedTypes) { |
| if (currentType.isSubtypeOf(type)) { |
| CatchClause lastCatchClause = catchClauses.get(numOfCatchClauses - 1); |
| int offset = catchClause.getOffset(); |
| int length = lastCatchClause.getEnd() - offset; |
| errorReporter.reportErrorForOffset( |
| HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, |
| offset, |
| length, |
| currentType.getDisplayName(), |
| type.getDisplayName()); |
| return null; |
| } |
| } |
| visitedTypes.add(currentType); |
| } |
| safelyVisit(catchClause); |
| } else { |
| // Found catch clause clause that doesn't have an exception type, visit the block, but |
| // generate an error on any following catch clauses (and don't visit them). |
| safelyVisit(catchClause); |
| if (i + 1 != numOfCatchClauses) { |
| // this catch clause is not the last in the try statement |
| CatchClause nextCatchClause = catchClauses.get(i + 1); |
| CatchClause lastCatchClause = catchClauses.get(numOfCatchClauses - 1); |
| int offset = nextCatchClause.getOffset(); |
| int length = lastCatchClause.getEnd() - offset; |
| errorReporter.reportErrorForOffset( |
| HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, |
| offset, |
| length); |
| return null; |
| } |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public Void visitWhileStatement(WhileStatement node) { |
| Expression conditionExpression = node.getCondition(); |
| safelyVisit(conditionExpression); |
| if (!isDebugConstant(conditionExpression)) { |
| EvaluationResultImpl result = getConstantBooleanValue(conditionExpression); |
| if (result != null) { |
| if (result.getValue().isFalse()) { |
| // report error on if block: while (false) {!} |
| errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.getBody()); |
| return null; |
| } |
| } |
| } |
| safelyVisit(node.getBody()); |
| return null; |
| } |
| |
| /** |
| * Given some {@link NodeList} of {@link Statement}s, from either a {@link Block} or |
| * {@link SwitchMember}, this loops through the list in reverse order searching for statements |
| * after a return, unlabeled break or unlabeled continue statement to mark them as dead code. |
| * |
| * @param statements some ordered list of statements in a {@link Block} or {@link SwitchMember} |
| */ |
| private void checkForDeadStatementsInNodeList(NodeList<Statement> statements) { |
| int size = statements.size(); |
| for (int i = 0; i < size; i++) { |
| Statement currentStatement = statements.get(i); |
| safelyVisit(currentStatement); |
| boolean returnOrBreakingStatement = currentStatement instanceof ReturnStatement |
| || (currentStatement instanceof BreakStatement && ((BreakStatement) currentStatement).getLabel() == null) |
| || (currentStatement instanceof ContinueStatement && ((ContinueStatement) currentStatement).getLabel() == null); |
| if (returnOrBreakingStatement && i != size - 1) { |
| Statement nextStatement = statements.get(i + 1); |
| Statement lastStatement = statements.get(size - 1); |
| int offset = nextStatement.getOffset(); |
| int length = lastStatement.getEnd() - offset; |
| errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Given some {@link Expression}, this method returns {@link ValidResult#RESULT_TRUE} if it is |
| * {@code true}, {@link ValidResult#RESULT_FALSE} if it is {@code false}, or {@code null} if the |
| * expression is not a constant boolean value. |
| * |
| * @param expression the expression to evaluate |
| * @return {@link ValidResult#RESULT_TRUE} if it is {@code true}, {@link ValidResult#RESULT_FALSE} |
| * if it is {@code false}, or {@code null} if the expression is not a constant boolean |
| * value |
| */ |
| private EvaluationResultImpl getConstantBooleanValue(Expression expression) { |
| if (expression instanceof BooleanLiteral) { |
| if (((BooleanLiteral) expression).getValue()) { |
| return new EvaluationResultImpl(new DartObjectImpl(null, BoolState.from(true))); |
| } else { |
| return new EvaluationResultImpl(new DartObjectImpl(null, BoolState.from(false))); |
| } |
| } |
| // Don't consider situations where we could evaluate to a constant boolean expression with the |
| // ConstantVisitor |
| // else { |
| // EvaluationResultImpl result = expression.accept(new ConstantVisitor()); |
| // if (result == ValidResult.RESULT_TRUE) { |
| // return ValidResult.RESULT_TRUE; |
| // } else if (result == ValidResult.RESULT_FALSE) { |
| // return ValidResult.RESULT_FALSE; |
| // } |
| // return null; |
| // } |
| return null; |
| } |
| |
| /** |
| * Return {@code true} if and only if the passed expression is resolved to a constant variable. |
| * |
| * @param expression some conditional expression |
| * @return {@code true} if and only if the passed expression is resolved to a constant variable |
| */ |
| private boolean isDebugConstant(Expression expression) { |
| Element element = null; |
| if (expression instanceof Identifier) { |
| Identifier identifier = (Identifier) expression; |
| element = identifier.getStaticElement(); |
| } else if (expression instanceof PropertyAccess) { |
| PropertyAccess propertyAccess = (PropertyAccess) expression; |
| element = propertyAccess.getPropertyName().getStaticElement(); |
| } |
| if (element instanceof PropertyAccessorElement) { |
| PropertyAccessorElement pae = (PropertyAccessorElement) element; |
| PropertyInducingElement variable = pae.getVariable(); |
| return variable != null && variable.isConst(); |
| } |
| return false; |
| } |
| |
| /** |
| * If the given node is not {@code null}, visit this instance of the dead code verifier. |
| * |
| * @param node the node to be visited |
| */ |
| private void safelyVisit(AstNode node) { |
| if (node != null) { |
| node.accept(this); |
| } |
| } |
| |
| } |
