1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/*******************************************************************************
* Copyright (c) 2009, 2010 Alena Laskavaia
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Alena Laskavaia - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.codan.internal.checkers;
import org.eclipse.cdt.codan.core.cxx.CxxAstUtils;
import org.eclipse.cdt.codan.core.cxx.model.AbstractIndexAstChecker;
import org.eclipse.cdt.codan.core.model.IProblemWorkingCopy;
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression;
import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTExpressionStatement;
import org.eclipse.cdt.core.dom.ast.IASTIdExpression;
import org.eclipse.cdt.core.dom.ast.IASTImplicitName;
import org.eclipse.cdt.core.dom.ast.IASTImplicitNameOwner;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
import org.eclipse.cdt.core.dom.ast.IBasicType;
import org.eclipse.cdt.core.dom.ast.gnu.IGNUASTCompoundStatementExpression;
/**
* Checker that detects statements without effect such as
*
* a+b;
* or
* +b;
*
*
*/
public class StatementHasNoEffectChecker extends AbstractIndexAstChecker {
public static final String ER_ID = "org.eclipse.cdt.codan.internal.checkers.StatementHasNoEffectProblem"; //$NON-NLS-1$
public static final String PARAM_MACRO_ID = "macro"; //$NON-NLS-1$
public static final String PARAM_EXCEPT_ARG_LIST = "exceptions"; //$NON-NLS-1$
@Override
public void processAst(IASTTranslationUnit ast) {
ast.accept(new CheckStmpVisitor());
}
class CheckStmpVisitor extends ASTVisitor {
CheckStmpVisitor() {
shouldVisitStatements = true;
}
@Override
public int visit(IASTStatement stmt) {
if (stmt instanceof IASTExpressionStatement) {
IASTExpression expression = ((IASTExpressionStatement) stmt).getExpression();
if (hasNoEffect(expression)) {
if (!shouldReportInMacro() && CxxAstUtils.isInMacro(expression))
return PROCESS_SKIP;
String arg = expression.getRawSignature();
if (!isFilteredArg(arg))
reportProblem(ER_ID, stmt, arg);
}
return PROCESS_SKIP;
}
return PROCESS_CONTINUE;
}
/**
* We consider has not effect binary statements without assignment and
* unary statement which is not dec and inc. If operator is overloaded
* we not going to bother.
*
* @param e
* @return
*/
private boolean hasNoEffect(IASTExpression e) {
if (e instanceof IASTBinaryExpression) {
IASTBinaryExpression binExpr = (IASTBinaryExpression) e;
if (isPossibleAssignment(binExpr))
return false;
if (usesOverloadedOperator(binExpr))
return false;
switch (binExpr.getOperator()) {
case IASTBinaryExpression.op_logicalOr:
case IASTBinaryExpression.op_logicalAnd:
return hasNoEffect(binExpr.getOperand1()) && hasNoEffect(binExpr.getOperand2());
}
return true;
}
if (e instanceof IASTUnaryExpression) {
IASTUnaryExpression unaryExpr = (IASTUnaryExpression) e;
if (usesOverloadedOperator(unaryExpr))
return false;
int operator = unaryExpr.getOperator();
switch (operator) {
case IASTUnaryExpression.op_postFixDecr:
case IASTUnaryExpression.op_prefixDecr:
case IASTUnaryExpression.op_postFixIncr:
case IASTUnaryExpression.op_prefixIncr:
case IASTUnaryExpression.op_throw:
return false;
case IASTUnaryExpression.op_bracketedPrimary:
return hasNoEffect(unaryExpr.getOperand());
}
return true;
}
// simply a;
if (e instanceof IASTIdExpression) {
// check if it is part of GNU comp stmt expression i.e. ({foo();a;})
IASTNode parent = e.getParent();
if (parent instanceof IASTExpressionStatement) {
IASTNode parent2 = parent.getParent();
if (parent2 instanceof IASTCompoundStatement) {
IASTNode parent3 = parent2.getParent();
if (parent3 instanceof IGNUASTCompoundStatementExpression) {
return false;
}
}
}
return true;
}
return false;
}
}
@Override
public void initPreferences(IProblemWorkingCopy problem) {
super.initPreferences(problem);
addPreference(problem, PARAM_MACRO_ID, CheckersMessages.StatementHasNoEffectChecker_ParameterMacro, Boolean.TRUE);
addListPreference(problem, PARAM_EXCEPT_ARG_LIST, CheckersMessages.GenericParameter_ParameterExceptions,
CheckersMessages.GenericParameter_ParameterExceptionsItem);
}
private boolean isFilteredArg(String arg) {
return isFilteredArg(arg, getProblemById(ER_ID, getFile()), PARAM_EXCEPT_ARG_LIST);
}
/**
* @return
*/
private boolean shouldReportInMacro() {
return (Boolean) getPreference(getProblemById(ER_ID, getFile()), PARAM_MACRO_ID);
}
public boolean isPossibleAssignment(IASTBinaryExpression expr) {
switch (expr.getOperator()) {
case IASTBinaryExpression.op_assign:
case IASTBinaryExpression.op_binaryAndAssign:
case IASTBinaryExpression.op_binaryOrAssign:
case IASTBinaryExpression.op_binaryXorAssign:
case IASTBinaryExpression.op_divideAssign:
case IASTBinaryExpression.op_minusAssign:
case IASTBinaryExpression.op_moduloAssign:
case IASTBinaryExpression.op_multiplyAssign:
case IASTBinaryExpression.op_plusAssign:
case IASTBinaryExpression.op_shiftLeftAssign:
case IASTBinaryExpression.op_shiftRightAssign:
return true;
}
return false;
}
private boolean usesOverloadedOperator(IASTBinaryExpression expr) {
if (expr instanceof IASTImplicitNameOwner) {
IASTImplicitName[] implicitNames = ((IASTImplicitNameOwner) expr).getImplicitNames();
if (implicitNames.length > 0)
return true;
IASTExpression operand1 = expr.getOperand1();
IASTExpression operand2 = expr.getOperand2();
// This shouldn't happen, but if it does, it's better to have a
// false negative than a false positive warning.
if (operand1 == null || operand2 == null)
return true;
if (!(operand1.getExpressionType() instanceof IBasicType && operand2.getExpressionType() instanceof IBasicType)) {
return true; // must be overloaded but parser could not find it
}
}
return false;
}
private boolean usesOverloadedOperator(IASTUnaryExpression expr) {
if (expr instanceof IASTImplicitNameOwner) {
IASTImplicitName[] implicitNames = ((IASTImplicitNameOwner) expr).getImplicitNames();
if (implicitNames.length > 0)
return true;
IASTExpression operand = expr.getOperand();
// This shouldn't happen, but if it does, it's better to have a
// false negative than a false positive warning.
if (operand == null)
return true;
if (!(operand.getExpressionType() instanceof IBasicType)) {
return true; // must be overloaded but parser could not find it
}
}
return false;
}
}
|
