[clang-tidy] Fix modernize-use-override incorrect replacement

[vgao]

Summary

For the following code: modernize-use-override generates a replacement with incorrect location.

struct IntPair
{
  int first, second;
};

struct A
{
  virtual void il(IntPair);
};

struct B : A
{
  void il(IntPair p = {1, (2 + 3)}) {};
  // Generated Fixit: void il(IntPair p = override {1, (2 + 3)}) {};
  // Should be: void il(IntPair p = {1, (2 + 3)}) override {};
};

This fixes that and adds a unit test.

[alexfh]

Looks good with a nit.

Thank you for the fix!

clang-tidy/modernize/UseOverrideCheck.cpp

43 ↗

(On Diff #105495)

s/!Parens/Parens == 0/

Maybe also change Parens to NestedParens or NestingLevel.

[vgao]

Change variable name Parens to NestedParens

[vgao]

@alexfh Could you please land this for me? Thanks!

clang-tools-extra/trunk/clang-tidy/modernize/UseOverrideCheck.cpp

std::pair<FileID, unsigned> LocInfo =
       Sources.getDecomposedLoc(Range.getBegin());
   StringRef File = Sources.getBufferData(LocInfo.first);
   const char *TokenBegin = File.data() + LocInfo.second;
   Lexer RawLexer(Sources.getLocForStartOfFile(LocInfo.first),
                  Result.Context->getLangOpts(), File.begin(), TokenBegin,
                  File.end());
   SmallVector<Token, 16> Tokens;
   Token Tok;
+  int NestedParens = 0;
   while (!RawLexer.LexFromRawLexer(Tok)) {
-    if (Tok.is(tok::semi) || Tok.is(tok::l_brace))
+    if ((Tok.is(tok::semi) || Tok.is(tok::l_brace)) && NestedParens == 0)
       break;
     if (Sources.isBeforeInTranslationUnit(Range.getEnd(), Tok.getLocation()))
       break;
+    if (Tok.is(tok::l_paren))
+      ++NestedParens;
+    else if (Tok.is(tok::r_paren))
+      --NestedParens;
     if (Tok.is(tok::raw_identifier)) {
       IdentifierInfo &Info = Result.Context->Idents.get(StringRef(
           Sources.getCharacterData(Tok.getLocation()), Tok.getLength()));
       Tok.setIdentifierInfo(&Info);
       Tok.setKind(Info.getTokenID());
     }
     Tokens.push_back(Tok);
   }

clang-tools-extra/trunk/test/clang-tidy/modernize-use-override.cpp

 // RUN: %check_clang_tidy %s modernize-use-override %t -- -- -std=c++11 -fexceptions
 
 #define ABSTRACT = 0
 
 #define OVERRIDE override
 #define VIRTUAL virtual
 #define NOT_VIRTUAL
 #define NOT_OVERRIDE
 
 #define MUST_USE_RESULT __attribute__((warn_unused_result))
 #define UNUSED __attribute__((unused))
 
 struct MUST_USE_RESULT MustUseResultObject {};
 
+struct IntPair {
+  int First, Second;
+};
+
 struct Base {
   virtual ~Base() {}
   virtual void a();
   virtual void b();
   virtual void c();
   virtual void d();
   virtual void d2();
   virtual void e() = 0;
struct Base {
   virtual void r() &;
   virtual void rr() &&;
 
   virtual void cv() const volatile;
   virtual void cv2() const volatile;
 
   virtual void ne() noexcept(false);
   virtual void t() throw();
+
+  virtual void il(IntPair);
 };
 
 struct SimpleCases : public Base {
 public:
   virtual ~SimpleCases();
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
   // CHECK-FIXES: {{^}}  ~SimpleCases() override;
 
public:
   // CHECK-FIXES: {{^}}  void cv() const volatile override
 
   virtual void cv2() const volatile // some comment
   {}
   // CHECK-MESSAGES: :[[@LINE-2]]:16: warning: prefer using
   // CHECK-FIXES: {{^}}  void cv2() const volatile override // some comment
 };
 
+struct DefaultArguments : public Base {
+  // Tests for default arguments (with initializer lists).
+  // Make sure the override fix is placed after the argument list.
+  void il(IntPair p = {1, (2 + (3))}) {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: annotate this
+  // CHECK-FIXES: {{^}}  void il(IntPair p = {1, (2 + (3))}) override {}
+};
+
 struct Macros : public Base {
   // Tests for 'virtual' and 'override' being defined through macros. Basically
   // give up for now.
   NOT_VIRTUAL void a() NOT_OVERRIDE;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: annotate this
   // CHECK-FIXES: {{^}}  NOT_VIRTUAL void a() override NOT_OVERRIDE;
 
   VIRTUAL void b() NOT_OVERRIDE;