clang-tools-extra/docs/clang-tidy/checks/bugprone/branch-clone.rst

   1 .. title:: clang-tidy - bugprone-branch-clone
   2
   3 bugprone-branch-clone
   4 =====================
   5
   6 Checks for repeated branches in ``if/else if/else`` chains, consecutive
   7 repeated branches in ``switch`` statements and identical true and false
   8 branches in conditional operators.
   9
  10 .. code-block:: c++
  11
  12     if (test_value(x)) {
  13       y++;
  14       do_something(x, y);
  15     } else {
  16       y++;
  17       do_something(x, y);
  18     }
  19
  20 In this simple example (which could arise e.g. as a copy-paste error) the
  21 ``then`` and ``else`` branches are identical and the code is equivalent the
  22 following shorter and cleaner code:
  23
  24 .. code-block:: c++
  25
  26     test_value(x); // can be omitted unless it has side effects
  27     y++;
  28     do_something(x, y);
  29
  30
  31 If this is the intended behavior, then there is no reason to use a conditional
  32 statement; otherwise the issue can be solved by fixing the branch that is
  33 handled incorrectly.
  34
  35 The check detects repeated branches in longer ``if/else if/else`` chains
  36 where it would be even harder to notice the problem.
  37
  38 The check also detects repeated inner and outer ``if`` statements that may
  39 be a result of a copy-paste error. This check cannot currently detect
  40 identical inner and outer ``if`` statements if code is between the ``if``
  41 conditions. An example is as follows.
  42
  43 .. code-block:: c++
  44
  45     void test_warn_inner_if_1(int x) {
  46       if (x == 1) {    // warns, if with identical inner if
  47         if (x == 1)    // inner if is here
  48           ;
  49       if (x == 1) {    // does not warn, cannot detect
  50         int y = x;
  51         if (x == 1)
  52           ;
  53       }
  54     }
  55
  56
  57 In ``switch`` statements the check only reports repeated branches when they are
  58 consecutive, because it is relatively common that the ``case:`` labels have
  59 some natural ordering and rearranging them would decrease the readability of
  60 the code. For example:
  61
  62 .. code-block:: c++
  63
  64     switch (ch) {
  65     case 'a':
  66       return 10;
  67     case 'A':
  68       return 10;
  69     case 'b':
  70       return 11;
  71     case 'B':
  72       return 11;
  73     default:
  74       return 10;
  75     }
  76
  77 Here the check reports that the ``'a'`` and ``'A'`` branches are identical
  78 (and that the ``'b'`` and ``'B'`` branches are also identical), but does not
  79 report that the ``default:`` branch is also identical to the first two branches.
  80 If this is indeed the correct behavior, then it could be implemented as:
  81
  82 .. code-block:: c++
  83
  84     switch (ch) {
  85     case 'a':
  86     case 'A':
  87       return 10;
  88     case 'b':
  89     case 'B':
  90       return 11;
  91     default:
  92       return 10;
  93     }
  94
  95 Here the check does not warn for the repeated ``return 10;``, which is good if
  96 we want to preserve that ``'a'`` is before ``'b'`` and ``default:`` is the last
  97 branch.
  98
  99 Switch cases marked with the ``[[fallthrough]]`` attribute are ignored.
 100
 101 Finally, the check also examines conditional operators and reports code like:
 102
 103 .. code-block:: c++
 104
 105     return test_value(x) ? x : x;
 106
 107 Unlike if statements, the check does not detect chains of conditional
 108 operators.
 109
 110 Note: This check also reports situations where branches become identical only
 111 after preprocessing.