[clang-tidy] Ignore implicit code in bugprone-branch-clone

[PiotrZSL]

Summary

Implicit code like, template instances, compiler generated
code are not excluded in this check by using
TK_IgnoreUnlessSpelledInSource.

Fixes #62693

[donat.nagy]

For me it's an unfortunate surprise that Clang Tidy is only seeing the result of the template instantiation process where the type variables are substituted (I would've guessed that it's working on the original template body), but if that's the observed behavior, then this commit is a clean and straightforward fix.

I'd suggest adding another testcase that looks like

template <typename T>
int branch_clone_in_template(T t) {
  if (t) {
    return 42;
  } else {
    return 42;
  }
}
int use_template(int x) {
  return branch_clone_in_template<int>(x);
}

to clarify the behavior on cases where the checker encounters a "real" branch clone that happens to be in a template. I think we can/should merge your change even if it suppresses these true positives (as it's a self-contained change that replaces a serious issue with a minor limitation), but in that case we should mark this testcase with a FIXME comment to highlight this low-priority followup work. (Of course it's even better if you happen to have a quick idea which ensures that the checker can report "real" branch clones even if they're in templates.)

[PiotrZSL]

Add positive test

[donat.nagy]

If this freshly added testcase passes, then there is no reason to delay merging this commit. Thanks for the contribution :) !

clang-tools-extra/clang-tidy/bugprone/BranchCloneCheck.h

 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/bugprone/branch-clone.html
 class BranchCloneCheck : public ClangTidyCheck {
 public:
   BranchCloneCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  std::optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 };
 
 } // namespace clang::tidy::bugprone
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BRANCHCLONECHECK_H

clang-tools-extra/docs/ReleaseNotes.rst

 
 - New alias :doc:`cppcoreguidelines-use-default-member-init
   <clang-tidy/checks/cppcoreguidelines/use-default-member-init>` to
   :doc:`modernize-use-default-member-init
   <clang-tidy/checks/modernize/use-default-member-init>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- Fixed false-positive in :doc:`bugprone-branch-clone
+  <clang-tidy/checks/bugprone/branch-clone>` check by ignoring auto-generated
+  code, template instances, and implicit code patterns.
+
 - Improved :doc:`readability-redundant-string-cstr
   <clang-tidy/checks/readability/redundant-string-cstr>` check to recognise
   unnecessary ``std::string::c_str()`` and ``std::string::data()`` calls in
   arguments to ``std::print``, ``std::format`` or other functions listed in
   the ``StringParameterFunction`` check option.
 
 - Improved :doc:`bugprone-dangling-handle
   <clang-tidy/checks/bugprone/dangling-handle>` check enhancing detection of

clang-tools-extra/test/clang-tidy/checkers/bugprone/branch-clone.cpp

// CHECK-MESSAGES: :[[@LINE+1]]:3: warning: switch has 2 consecutive identical branches [bugprone-branch-clone]
   SEMICOLON_CASE_COLON(2)
     e++;
     e++;
   // CHECK-MESSAGES: :[[@LINE-11]]:3: note: expanded from macro 'SEMICOLON_CASE_COLON'
   // CHECK-MESSAGES: :[[@LINE+1]]:23: note: last of these clones ends here
   SEMICOLON_CASE_COLON(3);
   }
 }
+
+namespace PR62693 {
+  class Object {
+    public:
+      template <typename T>
+        bool ConvertableTo() const;
+
+      template <typename T>
+        void Handle();
+  };
+
+  template <typename T>
+  void update(Object &a) {
+    if (a.ConvertableTo<char *>()) {
+      a.Handle<char *>();
+    } else {
+      a.Handle<T>();
+    }
+  }
+
+  template <typename T>
+  void update2(Object &a) {
+    if (a.ConvertableTo<char *>()) {
+      a.Handle<char *>();
+    } else {
+      a.Handle<T>();
+    }
+  }
+
+  void foo(Object &a) {
+    update<int>(a);
+    update2<char *>(a);
+  }
+
+  template <typename T>
+  int branch_clone_in_template(T t) {
+    // CHECK-MESSAGES: :[[@LINE+2]]:5: warning: if with identical then and else branches [bugprone-branch-clone]
+    // CHECK-MESSAGES: :[[@LINE+3]]:7: note: else branch starts here
+    if (t) {
+      return 42;
+    } else {
+      return 42;
+    }
+  }
+}