Coverage Report

Created: 2020-09-22 08:39

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp
Line
Count
Source (jump to first uncovered line)
1
//== IdenticalExprChecker.cpp - Identical expression checker----------------==//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
///
9
/// \file
10
/// This defines IdenticalExprChecker, a check that warns about
11
/// unintended use of identical expressions.
12
///
13
/// It checks for use of identical expressions with comparison operators and
14
/// inside conditional expressions.
15
///
16
//===----------------------------------------------------------------------===//
17
18
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
19
#include "clang/AST/RecursiveASTVisitor.h"
20
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
21
#include "clang/StaticAnalyzer/Core/Checker.h"
22
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
23
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
24
25
using namespace clang;
26
using namespace ento;
27
28
static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
29
                            const Stmt *Stmt2, bool IgnoreSideEffects = false);
30
//===----------------------------------------------------------------------===//
31
// FindIdenticalExprVisitor - Identify nodes using identical expressions.
32
//===----------------------------------------------------------------------===//
33
34
namespace {
35
class FindIdenticalExprVisitor
36
    : public RecursiveASTVisitor<FindIdenticalExprVisitor> {
37
  BugReporter &BR;
38
  const CheckerBase *Checker;
39
  AnalysisDeclContext *AC;
40
public:
41
  explicit FindIdenticalExprVisitor(BugReporter &B,
42
                                    const CheckerBase *Checker,
43
                                    AnalysisDeclContext *A)
44
1.26k
      : BR(B), Checker(Checker), AC(A) {}
45
  // FindIdenticalExprVisitor only visits nodes
46
  // that are binary operators, if statements or
47
  // conditional operators.
48
  bool VisitBinaryOperator(const BinaryOperator *B);
49
  bool VisitIfStmt(const IfStmt *I);
50
  bool VisitConditionalOperator(const ConditionalOperator *C);
51
52
private:
53
  void reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise,
54
                           ArrayRef<SourceRange> Sr);
55
  void checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise);
56
  void checkComparisonOp(const BinaryOperator *B);
57
};
58
} // end anonymous namespace
59
60
void FindIdenticalExprVisitor::reportIdenticalExpr(const BinaryOperator *B,
61
                                                   bool CheckBitwise,
62
7
                                                   ArrayRef<SourceRange> Sr) {
63
7
  StringRef Message;
64
7
  if (CheckBitwise)
65
4
    Message = "identical expressions on both sides of bitwise operator";
66
3
  else
67
3
    Message = "identical expressions on both sides of logical operator";
68
69
7
  PathDiagnosticLocation ELoc =
70
7
      PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager());
71
7
  BR.EmitBasicReport(AC->getDecl(), Checker,
72
7
                     "Use of identical expressions",
73
7
                     categories::LogicError,
74
7
                     Message, ELoc, Sr);
75
7
}
76
77
void FindIdenticalExprVisitor::checkBitwiseOrLogicalOp(const BinaryOperator *B,
78
87
                                                       bool CheckBitwise) {
79
87
  SourceRange Sr[2];
80
81
87
  const Expr *LHS = B->getLHS();
82
87
  const Expr *RHS = B->getRHS();
83
84
  // Split operators as long as we still have operators to split on. We will
85
  // get called for every binary operator in an expression so there is no need
86
  // to check every one against each other here, just the right most one with
87
  // the others.
88
90
  while (const BinaryOperator *B2 = dyn_cast<BinaryOperator>(LHS)) {
89
29
    if (B->getOpcode() != B2->getOpcode())
90
26
      break;
91
3
    if (isIdenticalStmt(AC->getASTContext(), RHS, B2->getRHS())) {
92
0
      Sr[0] = RHS->getSourceRange();
93
0
      Sr[1] = B2->getRHS()->getSourceRange();
94
0
      reportIdenticalExpr(B, CheckBitwise, Sr);
95
0
    }
96
3
    LHS = B2->getLHS();
97
3
  }
98
99
87
  if (isIdenticalStmt(AC->getASTContext(), RHS, LHS)) {
100
7
    Sr[0] = RHS->getSourceRange();
101
7
    Sr[1] = LHS->getSourceRange();
102
7
    reportIdenticalExpr(B, CheckBitwise, Sr);
103
7
  }
104
87
}
105
106
557
bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) {
107
557
  const Stmt *Stmt1 = I->getThen();
108
557
  const Stmt *Stmt2 = I->getElse();
109
110
  // Check for identical inner condition:
111
  //
112
  // if (x<10) {
113
  //   if (x<10) {
114
  //   ..
115
557
  if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(Stmt1)) {
116
161
    if (!CS->body_empty()) {
117
138
      const IfStmt *InnerIf = dyn_cast<IfStmt>(*CS->body_begin());
118
138
      if (InnerIf && 
isIdenticalStmt(AC->getASTContext(), I->getCond(), InnerIf->getCond(), /*IgnoreSideEffects=*/ false)14
) {
119
1
        PathDiagnosticLocation ELoc(InnerIf->getCond(), BR.getSourceManager(), AC);
120
1
        BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions",
121
1
          categories::LogicError,
122
1
          "conditions of the inner and outer statements are identical",
123
1
          ELoc);
124
1
      }
125
138
    }
126
161
  }
127
128
  // Check for identical conditions:
129
  //
130
  // if (b) {
131
  //   foo1();
132
  // } else if (b) {
133
  //   foo2();
134
  // }
135
557
  if (Stmt1 && Stmt2) {
136
105
    const Expr *Cond1 = I->getCond();
137
105
    const Stmt *Else = Stmt2;
138
159
    while (const IfStmt *I2 = dyn_cast_or_null<IfStmt>(Else)) {
139
54
      const Expr *Cond2 = I2->getCond();
140
54
      if (isIdenticalStmt(AC->getASTContext(), Cond1, Cond2, false)) {
141
11
        SourceRange Sr = Cond1->getSourceRange();
142
11
        PathDiagnosticLocation ELoc(Cond2, BR.getSourceManager(), AC);
143
11
        BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions",
144
11
                           categories::LogicError,
145
11
                           "expression is identical to previous condition",
146
11
                           ELoc, Sr);
147
11
      }
148
54
      Else = I2->getElse();
149
54
    }
150
105
  }
151
152
557
  if (!Stmt1 || !Stmt2)
153
452
    return true;
154
155
  // Special handling for code like:
156
  //
157
  // if (b) {
158
  //   i = 1;
159
  // } else
160
  //   i = 1;
161
105
  if (const CompoundStmt *CompStmt = dyn_cast<CompoundStmt>(Stmt1)) {
162
28
    if (CompStmt->size() == 1)
163
15
      Stmt1 = CompStmt->body_back();
164
28
  }
165
105
  if (const CompoundStmt *CompStmt = dyn_cast<CompoundStmt>(Stmt2)) {
166
25
    if (CompStmt->size() == 1)
167
22
      Stmt2 = CompStmt->body_back();
168
25
  }
169
170
105
  if (isIdenticalStmt(AC->getASTContext(), Stmt1, Stmt2, true)) {
171
13
      PathDiagnosticLocation ELoc =
172
13
          PathDiagnosticLocation::createBegin(I, BR.getSourceManager(), AC);
173
13
      BR.EmitBasicReport(AC->getDecl(), Checker,
174
13
                         "Identical branches",
175
13
                         categories::LogicError,
176
13
                         "true and false branches are identical", ELoc);
177
13
  }
178
105
  return true;
179
105
}
180
181
2.01k
bool FindIdenticalExprVisitor::VisitBinaryOperator(const BinaryOperator *B) {
182
2.01k
  BinaryOperator::Opcode Op = B->getOpcode();
183
184
2.01k
  if (BinaryOperator::isBitwiseOp(Op))
185
26
    checkBitwiseOrLogicalOp(B, true);
186
187
2.01k
  if (BinaryOperator::isLogicalOp(Op))
188
61
    checkBitwiseOrLogicalOp(B, false);
189
190
2.01k
  if (BinaryOperator::isComparisonOp(Op))
191
841
    checkComparisonOp(B);
192
193
  // We want to visit ALL nodes (subexpressions of binary comparison
194
  // expressions too) that contains comparison operators.
195
  // True is always returned to traverse ALL nodes.
196
2.01k
  return true;
197
2.01k
}
198
199
841
void FindIdenticalExprVisitor::checkComparisonOp(const BinaryOperator *B) {
200
841
  BinaryOperator::Opcode Op = B->getOpcode();
201
202
  //
203
  // Special case for floating-point representation.
204
  //
205
  // If expressions on both sides of comparison operator are of type float,
206
  // then for some comparison operators no warning shall be
207
  // reported even if the expressions are identical from a symbolic point of
208
  // view. Comparison between expressions, declared variables and literals
209
  // are treated differently.
210
  //
211
  // != and == between float literals that have the same value should NOT warn.
212
  // < > between float literals that have the same value SHOULD warn.
213
  //
214
  // != and == between the same float declaration should NOT warn.
215
  // < > between the same float declaration SHOULD warn.
216
  //
217
  // != and == between eq. expressions that evaluates into float
218
  //           should NOT warn.
219
  // < >       between eq. expressions that evaluates into float
220
  //           should NOT warn.
221
  //
222
841
  const Expr *LHS = B->getLHS()->IgnoreParenImpCasts();
223
841
  const Expr *RHS = B->getRHS()->IgnoreParenImpCasts();
224
225
841
  const DeclRefExpr *DeclRef1 = dyn_cast<DeclRefExpr>(LHS);
226
841
  const DeclRefExpr *DeclRef2 = dyn_cast<DeclRefExpr>(RHS);
227
841
  const FloatingLiteral *FloatLit1 = dyn_cast<FloatingLiteral>(LHS);
228
841
  const FloatingLiteral *FloatLit2 = dyn_cast<FloatingLiteral>(RHS);
229
841
  if ((DeclRef1) && 
(DeclRef2)364
) {
230
68
    if ((DeclRef1->getType()->hasFloatingRepresentation()) &&
231
12
        (DeclRef2->getType()->hasFloatingRepresentation())) {
232
8
      if (DeclRef1->getDecl() == DeclRef2->getDecl()) {
233
4
        if ((Op == BO_EQ) || 
(Op == BO_NE)3
) {
234
2
          return;
235
2
        }
236
773
      }
237
8
    }
238
773
  } else if ((FloatLit1) && 
(FloatLit2)12
) {
239
8
    if (FloatLit1->getValue().bitwiseIsEqual(FloatLit2->getValue())) {
240
4
      if ((Op == BO_EQ) || 
(Op == BO_NE)3
) {
241
2
        return;
242
2
      }
243
765
    }
244
765
  } else if (LHS->getType()->hasFloatingRepresentation()) {
245
    // If any side of comparison operator still has floating-point
246
    // representation, then it's an expression. Don't warn.
247
    // Here only LHS is checked since RHS will be implicit casted to float.
248
43
    return;
249
722
  } else {
250
    // No special case with floating-point representation, report as usual.
251
722
  }
252
253
794
  if (isIdenticalStmt(AC->getASTContext(), B->getLHS(), B->getRHS())) {
254
39
    PathDiagnosticLocation ELoc =
255
39
        PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager());
256
39
    StringRef Message;
257
39
    if (Op == BO_Cmp)
258
0
      Message = "comparison of identical expressions always evaluates to "
259
0
                "'equal'";
260
39
    else if (((Op == BO_EQ) || 
(Op == BO_LE)30
||
(Op == BO_GE)30
))
261
9
      Message = "comparison of identical expressions always evaluates to true";
262
30
    else
263
30
      Message = "comparison of identical expressions always evaluates to false";
264
39
    BR.EmitBasicReport(AC->getDecl(), Checker,
265
39
                       "Compare of identical expressions",
266
39
                       categories::LogicError, Message, ELoc);
267
39
  }
268
794
}
269
270
bool FindIdenticalExprVisitor::VisitConditionalOperator(
271
58
    const ConditionalOperator *C) {
272
273
  // Check if expressions in conditional expression are identical
274
  // from a symbolic point of view.
275
276
58
  if (isIdenticalStmt(AC->getASTContext(), C->getTrueExpr(),
277
16
                      C->getFalseExpr(), true)) {
278
16
    PathDiagnosticLocation ELoc =
279
16
        PathDiagnosticLocation::createConditionalColonLoc(
280
16
            C, BR.getSourceManager());
281
282
16
    SourceRange Sr[2];
283
16
    Sr[0] = C->getTrueExpr()->getSourceRange();
284
16
    Sr[1] = C->getFalseExpr()->getSourceRange();
285
16
    BR.EmitBasicReport(
286
16
        AC->getDecl(), Checker,
287
16
        "Identical expressions in conditional expression",
288
16
        categories::LogicError,
289
16
        "identical expressions on both sides of ':' in conditional expression",
290
16
        ELoc, Sr);
291
16
  }
292
  // We want to visit ALL nodes (expressions in conditional
293
  // expressions too) that contains conditional operators,
294
  // thus always return true to traverse ALL nodes.
295
58
  return true;
296
58
}
297
298
/// Determines whether two statement trees are identical regarding
299
/// operators and symbols.
300
///
301
/// Exceptions: expressions containing macros or functions with possible side
302
/// effects are never considered identical.
303
/// Limitations: (t + u) and (u + t) are not considered identical.
304
/// t*(u + t) and t*u + t*t are not considered identical.
305
///
306
static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
307
2.12k
                            const Stmt *Stmt2, bool IgnoreSideEffects) {
308
309
2.12k
  if (!Stmt1 || 
!Stmt22.11k
) {
310
1
    return !Stmt1 && !Stmt2;
311
1
  }
312
313
  // If Stmt1 & Stmt2 are of different class then they are not
314
  // identical statements.
315
2.11k
  if (Stmt1->getStmtClass() != Stmt2->getStmtClass())
316
762
    return false;
317
318
1.35k
  const Expr *Expr1 = dyn_cast<Expr>(Stmt1);
319
1.35k
  const Expr *Expr2 = dyn_cast<Expr>(Stmt2);
320
321
1.35k
  if (Expr1 && 
Expr21.34k
) {
322
    // If Stmt1 has side effects then don't warn even if expressions
323
    // are identical.
324
1.34k
    if (!IgnoreSideEffects && 
Expr1->HasSideEffects(Ctx)964
)
325
33
      return false;
326
    // If either expression comes from a macro then don't warn even if
327
    // the expressions are identical.
328
1.30k
    if ((Expr1->getExprLoc().isMacroID()) || 
(Expr2->getExprLoc().isMacroID())1.30k
)
329
21
      return false;
330
331
    // If all children of two expressions are identical, return true.
332
1.28k
    Expr::const_child_iterator I1 = Expr1->child_begin();
333
1.28k
    Expr::const_child_iterator I2 = Expr2->child_begin();
334
1.79k
    while (I1 != Expr1->child_end() && 
I2 != Expr2->child_end()983
) {
335
983
      if (!*I1 || !*I2 || !isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects))
336
478
        return false;
337
505
      ++I1;
338
505
      ++I2;
339
505
    }
340
    // If there are different number of children in the statements, return
341
    // false.
342
810
    if (I1 != Expr1->child_end())
343
0
      return false;
344
810
    if (I2 != Expr2->child_end())
345
0
      return false;
346
825
  }
347
348
825
  switch (Stmt1->getStmtClass()) {
349
18
  default:
350
18
    return false;
351
224
  case Stmt::CallExprClass:
352
224
  case Stmt::ArraySubscriptExprClass:
353
224
  case Stmt::OMPArraySectionExprClass:
354
224
  case Stmt::OMPArrayShapingExprClass:
355
224
  case Stmt::OMPIteratorExprClass:
356
224
  case Stmt::ImplicitCastExprClass:
357
224
  case Stmt::ParenExprClass:
358
224
  case Stmt::BreakStmtClass:
359
224
  case Stmt::ContinueStmtClass:
360
224
  case Stmt::NullStmtClass:
361
224
    return true;
362
28
  case Stmt::CStyleCastExprClass: {
363
28
    const CStyleCastExpr* CastExpr1 = cast<CStyleCastExpr>(Stmt1);
364
28
    const CStyleCastExpr* CastExpr2 = cast<CStyleCastExpr>(Stmt2);
365
366
28
    return CastExpr1->getTypeAsWritten() == CastExpr2->getTypeAsWritten();
367
224
  }
368
4
  case Stmt::ReturnStmtClass: {
369
4
    const ReturnStmt *ReturnStmt1 = cast<ReturnStmt>(Stmt1);
370
4
    const ReturnStmt *ReturnStmt2 = cast<ReturnStmt>(Stmt2);
371
372
4
    return isIdenticalStmt(Ctx, ReturnStmt1->getRetValue(),
373
4
                           ReturnStmt2->getRetValue(), IgnoreSideEffects);
374
224
  }
375
1
  case Stmt::ForStmtClass: {
376
1
    const ForStmt *ForStmt1 = cast<ForStmt>(Stmt1);
377
1
    const ForStmt *ForStmt2 = cast<ForStmt>(Stmt2);
378
379
1
    if (!isIdenticalStmt(Ctx, ForStmt1->getInit(), ForStmt2->getInit(),
380
1
                         IgnoreSideEffects))
381
0
      return false;
382
1
    if (!isIdenticalStmt(Ctx, ForStmt1->getCond(), ForStmt2->getCond(),
383
1
                         IgnoreSideEffects))
384
0
      return false;
385
1
    if (!isIdenticalStmt(Ctx, ForStmt1->getInc(), ForStmt2->getInc(),
386
1
                         IgnoreSideEffects))
387
0
      return false;
388
1
    if (!isIdenticalStmt(Ctx, ForStmt1->getBody(), ForStmt2->getBody(),
389
1
                         IgnoreSideEffects))
390
0
      return false;
391
1
    return true;
392
1
  }
393
1
  case Stmt::DoStmtClass: {
394
1
    const DoStmt *DStmt1 = cast<DoStmt>(Stmt1);
395
1
    const DoStmt *DStmt2 = cast<DoStmt>(Stmt2);
396
397
1
    if (!isIdenticalStmt(Ctx, DStmt1->getCond(), DStmt2->getCond(),
398
1
                         IgnoreSideEffects))
399
0
      return false;
400
1
    if (!isIdenticalStmt(Ctx, DStmt1->getBody(), DStmt2->getBody(),
401
1
                         IgnoreSideEffects))
402
0
      return false;
403
1
    return true;
404
1
  }
405
2
  case Stmt::WhileStmtClass: {
406
2
    const WhileStmt *WStmt1 = cast<WhileStmt>(Stmt1);
407
2
    const WhileStmt *WStmt2 = cast<WhileStmt>(Stmt2);
408
409
2
    if (!isIdenticalStmt(Ctx, WStmt1->getCond(), WStmt2->getCond(),
410
2
                         IgnoreSideEffects))
411
0
      return false;
412
2
    if (!isIdenticalStmt(Ctx, WStmt1->getBody(), WStmt2->getBody(),
413
2
                         IgnoreSideEffects))
414
1
      return false;
415
1
    return true;
416
1
  }
417
1
  case Stmt::IfStmtClass: {
418
1
    const IfStmt *IStmt1 = cast<IfStmt>(Stmt1);
419
1
    const IfStmt *IStmt2 = cast<IfStmt>(Stmt2);
420
421
1
    if (!isIdenticalStmt(Ctx, IStmt1->getCond(), IStmt2->getCond(),
422
1
                         IgnoreSideEffects))
423
0
      return false;
424
1
    if (!isIdenticalStmt(Ctx, IStmt1->getThen(), IStmt2->getThen(),
425
1
                         IgnoreSideEffects))
426
0
      return false;
427
1
    if (!isIdenticalStmt(Ctx, IStmt1->getElse(), IStmt2->getElse(),
428
1
                         IgnoreSideEffects))
429
0
      return false;
430
1
    return true;
431
1
  }
432
4
  case Stmt::CompoundStmtClass: {
433
4
    const CompoundStmt *CompStmt1 = cast<CompoundStmt>(Stmt1);
434
4
    const CompoundStmt *CompStmt2 = cast<CompoundStmt>(Stmt2);
435
436
4
    if (CompStmt1->size() != CompStmt2->size())
437
0
      return false;
438
439
4
    CompoundStmt::const_body_iterator I1 = CompStmt1->body_begin();
440
4
    CompoundStmt::const_body_iterator I2 = CompStmt2->body_begin();
441
8
    while (I1 != CompStmt1->body_end() && 
I2 != CompStmt2->body_end()5
) {
442
5
      if (!isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects))
443
1
        return false;
444
4
      ++I1;
445
4
      ++I2;
446
4
    }
447
448
3
    return true;
449
4
  }
450
76
  case Stmt::CompoundAssignOperatorClass:
451
76
  case Stmt::BinaryOperatorClass: {
452
76
    const BinaryOperator *BinOp1 = cast<BinaryOperator>(Stmt1);
453
76
    const BinaryOperator *BinOp2 = cast<BinaryOperator>(Stmt2);
454
76
    return BinOp1->getOpcode() == BinOp2->getOpcode();
455
76
  }
456
0
  case Stmt::CharacterLiteralClass: {
457
0
    const CharacterLiteral *CharLit1 = cast<CharacterLiteral>(Stmt1);
458
0
    const CharacterLiteral *CharLit2 = cast<CharacterLiteral>(Stmt2);
459
0
    return CharLit1->getValue() == CharLit2->getValue();
460
76
  }
461
326
  case Stmt::DeclRefExprClass: {
462
326
    const DeclRefExpr *DeclRef1 = cast<DeclRefExpr>(Stmt1);
463
326
    const DeclRefExpr *DeclRef2 = cast<DeclRefExpr>(Stmt2);
464
326
    return DeclRef1->getDecl() == DeclRef2->getDecl();
465
76
  }
466
120
  case Stmt::IntegerLiteralClass: {
467
120
    const IntegerLiteral *IntLit1 = cast<IntegerLiteral>(Stmt1);
468
120
    const IntegerLiteral *IntLit2 = cast<IntegerLiteral>(Stmt2);
469
470
120
    llvm::APInt I1 = IntLit1->getValue();
471
120
    llvm::APInt I2 = IntLit2->getValue();
472
120
    if (I1.getBitWidth() != I2.getBitWidth())
473
1
      return false;
474
119
    return  I1 == I2;
475
119
  }
476
6
  case Stmt::FloatingLiteralClass: {
477
6
    const FloatingLiteral *FloatLit1 = cast<FloatingLiteral>(Stmt1);
478
6
    const FloatingLiteral *FloatLit2 = cast<FloatingLiteral>(Stmt2);
479
6
    return FloatLit1->getValue().bitwiseIsEqual(FloatLit2->getValue());
480
119
  }
481
3
  case Stmt::StringLiteralClass: {
482
3
    const StringLiteral *StringLit1 = cast<StringLiteral>(Stmt1);
483
3
    const StringLiteral *StringLit2 = cast<StringLiteral>(Stmt2);
484
3
    return StringLit1->getBytes() == StringLit2->getBytes();
485
119
  }
486
0
  case Stmt::MemberExprClass: {
487
0
    const MemberExpr *MemberStmt1 = cast<MemberExpr>(Stmt1);
488
0
    const MemberExpr *MemberStmt2 = cast<MemberExpr>(Stmt2);
489
0
    return MemberStmt1->getMemberDecl() == MemberStmt2->getMemberDecl();
490
119
  }
491
11
  case Stmt::UnaryOperatorClass: {
492
11
    const UnaryOperator *UnaryOp1 = cast<UnaryOperator>(Stmt1);
493
11
    const UnaryOperator *UnaryOp2 = cast<UnaryOperator>(Stmt2);
494
11
    return UnaryOp1->getOpcode() == UnaryOp2->getOpcode();
495
119
  }
496
825
  }
497
825
}
498
499
//===----------------------------------------------------------------------===//
500
// FindIdenticalExprChecker
501
//===----------------------------------------------------------------------===//
502
503
namespace {
504
class FindIdenticalExprChecker : public Checker<check::ASTCodeBody> {
505
public:
506
  void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
507
1.26k
                        BugReporter &BR) const {
508
1.26k
    FindIdenticalExprVisitor Visitor(BR, this, Mgr.getAnalysisDeclContext(D));
509
1.26k
    Visitor.TraverseDecl(const_cast<Decl *>(D));
510
1.26k
  }
511
};
512
} // end anonymous namespace
513
514
69
void ento::registerIdenticalExprChecker(CheckerManager &Mgr) {
515
69
  Mgr.registerChecker<FindIdenticalExprChecker>();
516
69
}
517
518
138
bool ento::shouldRegisterIdenticalExprChecker(const CheckerManager &mgr) {
519
138
  return true;
520
138
}