[clang-tidy] Harden PreferMemberInitializerCheck

[njames93]

Summary

Prevent warning when the values are initialized using fields that will be initialized later or VarDecls defined in the constructors body.
Both of these cases can't be safely fixed.
Also improve logic of finding where to insert member initializers, previously it could be confused by in class member initializers.

[njames93]

Fix potential crash if macros are used, Now we just don't try to emit a fix.
Fix issue where FixIt for member initializers would be inserted at the start of the constructor decl due to implicit member initializers confusing it.
Streamlined method for finding where to create member initializers when there's no member initializer list.

[aaron.ballman]

Fix potential crash if macros are used, Now we just don't try to emit a fix.

Can you add a test case that covers this change?

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

103

121

[njames93]

In D97132#2578992, @aaron.ballman wrote:

Fix potential crash if macros are used, Now we just don't try to emit a fix.

Can you add a test case that covers this change?

I can try, but I'm not sure of the exact cause of it. It happened when running the check over clang codebase.
The assert was caused by not checking the Optional returned from findNextToken which can fail if the location passed is at the end of a macro expansion.

[njames93]

Add a test for the crash fix.

[njames93]

Address auto comments.

[aaron.ballman]

LGTM, thanks!

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

if (isLiteral(Value) || isUnaryExprOfLiteral(Value))
     return true;
 
   if (const auto *DRE = dyn_cast<DeclRefExpr>(Value))
     return isa<EnumConstantDecl>(DRE->getDecl());
 
   return false;
 }
 
+namespace {
+AST_MATCHER_P(FieldDecl, indexNotLessThan, unsigned, Index) {
+  return Node.getFieldIndex() >= Index;
+}
+} // namespace
+
+// Checks if Field is initialised using a field that will be initialised after
+// it.
+// TODO: Probably should guard against function calls that could have side
+// effects or if they do reference another field that's initialized before this
+// field, but is modified before the assignment.
+static bool isSafeAssignment(const FieldDecl *Field, const Expr *Init,
+                             const CXXConstructorDecl *Context) {
+
+  auto MemberMatcher =
+      memberExpr(hasObjectExpression(cxxThisExpr()),
+                 member(fieldDecl(indexNotLessThan(Field->getFieldIndex()))));
+
+  auto DeclMatcher = declRefExpr(
+      to(varDecl(unless(parmVarDecl()), hasDeclContext(equalsNode(Context)))));
+
+  return match(expr(anyOf(MemberMatcher, DeclMatcher,
+                          hasDescendant(MemberMatcher),
+                          hasDescendant(DeclMatcher))),
+               *Init, Field->getASTContext())
+      .empty();
+}
+
 static const std::pair<const FieldDecl *, const Expr *>
-isAssignmentToMemberOf(const RecordDecl *Rec, const Stmt *S) {
+isAssignmentToMemberOf(const CXXRecordDecl *Rec, const Stmt *S,
+                       const CXXConstructorDecl *Ctor) {
   if (const auto *BO = dyn_cast<BinaryOperator>(S)) {
     if (BO->getOpcode() != BO_Assign)
       return std::make_pair(nullptr, nullptr);
 
     const auto *ME = dyn_cast<MemberExpr>(BO->getLHS()->IgnoreParenImpCasts());
     if (!ME)
       return std::make_pair(nullptr, nullptr);
 
     const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
     if (!Field)
       return std::make_pair(nullptr, nullptr);
 
-    if (isa<CXXThisExpr>(ME->getBase()))
-      return std::make_pair(Field, BO->getRHS()->IgnoreParenImpCasts());
+    if (!isa<CXXThisExpr>(ME->getBase()))
+      return std::make_pair(nullptr, nullptr);
+    const Expr *Init = BO->getRHS()->IgnoreParenImpCasts();
+    if (isSafeAssignment(Field, Init, Ctor))
+      return std::make_pair(Field, Init);
   } else if (const auto *COCE = dyn_cast<CXXOperatorCallExpr>(S)) {
     if (COCE->getOperator() != OO_Equal)
       return std::make_pair(nullptr, nullptr);
 
     const auto *ME =
         dyn_cast<MemberExpr>(COCE->getArg(0)->IgnoreParenImpCasts());
     if (!ME)
       return std::make_pair(nullptr, nullptr);
 
     const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
     if (!Field)
       return std::make_pair(nullptr, nullptr);
 
-    if (isa<CXXThisExpr>(ME->getBase()))
-      return std::make_pair(Field, COCE->getArg(1)->IgnoreParenImpCasts());
+    if (!isa<CXXThisExpr>(ME->getBase()))
+      return std::make_pair(nullptr, nullptr);
+    const Expr *Init = COCE->getArg(1)->IgnoreParenImpCasts();
+    if (isSafeAssignment(Field, Init, Ctor))
+      return std::make_pair(Field, Init);
   }
 
   return std::make_pair(nullptr, nullptr);
 }
 
 PreferMemberInitializerCheck::PreferMemberInitializerCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),

 }
 
 void PreferMemberInitializerCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
   const auto *Body = cast<CompoundStmt>(Ctor->getBody());
 
   const CXXRecordDecl *Class = Ctor->getParent();
-  SourceLocation InsertPos;
   bool FirstToCtorInits = true;
 
   for (const Stmt *S : Body->body()) {
     if (S->getBeginLoc().isMacroID()) {
-      StringRef MacroName =
-        Lexer::getImmediateMacroName(S->getBeginLoc(), *Result.SourceManager,
-                                     getLangOpts());
+      StringRef MacroName = Lexer::getImmediateMacroName(
+          S->getBeginLoc(), *Result.SourceManager, getLangOpts());
       if (MacroName.contains_lower("assert"))
         return;
     }
     if (isControlStatement(S))
       return;
 
     if (isNoReturnCallStatement(S))
       return;
 
     if (const auto *CondOp = dyn_cast<ConditionalOperator>(S)) {
       if (isNoReturnCallStatement(CondOp->getLHS()) ||
           isNoReturnCallStatement(CondOp->getRHS()))
         return;
     }
 
     const FieldDecl *Field;
     const Expr *InitValue;
-    std::tie(Field, InitValue) = isAssignmentToMemberOf(Class, S);
+    std::tie(Field, InitValue) = isAssignmentToMemberOf(Class, S, Ctor);
     if (Field) {
       if (IsUseDefaultMemberInitEnabled && getLangOpts().CPlusPlus11 &&
           Ctor->isDefaultConstructor() &&
           (getLangOpts().CPlusPlus20 || !Field->isBitField()) &&
+          !Field->hasInClassInitializer() &&
           (!isa<RecordDecl>(Class->getDeclContext()) ||
            !cast<RecordDecl>(Class->getDeclContext())->isUnion()) &&
           shouldBeDefaultMemberInitializer(InitValue)) {
 
+        bool InvalidFix = false;
         SourceLocation FieldEnd =
             Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
                                        *Result.SourceManager, getLangOpts());
+        InvalidFix |= FieldEnd.isInvalid() || FieldEnd.isMacroID();
+        SourceLocation SemiColonEnd;
+        if (auto NextToken = Lexer::findNextToken(
+                S->getEndLoc(), *Result.SourceManager, getLangOpts()))
+          SemiColonEnd = NextToken->getEndLoc();
+        else
+          InvalidFix = true;
+        auto Diag =
+            diag(S->getBeginLoc(), "%0 should be initialized in an in-class"
+                                   " default member initializer")
+            << Field;
+        if (!InvalidFix) {
+          CharSourceRange StmtRange =
+              CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
+
           SmallString<128> Insertion(
               {UseAssignment ? " = " : "{",
                Lexer::getSourceText(
                    CharSourceRange(InitValue->getSourceRange(), true),
                    *Result.SourceManager, getLangOpts()),
                UseAssignment ? "" : "}"});
 
-        SourceLocation SemiColonEnd =
-            Lexer::findNextToken(S->getEndLoc(), *Result.SourceManager,
-                                 getLangOpts())
-                ->getEndLoc();
-        CharSourceRange StmtRange =
-            CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
-
-        diag(S->getBeginLoc(), "%0 should be initialized in an in-class"
-                               " default member initializer")
-            << Field << FixItHint::CreateInsertion(FieldEnd, Insertion)
+          Diag << FixItHint::CreateInsertion(FieldEnd, Insertion)
                << FixItHint::CreateRemoval(StmtRange);
+        }
       } else {
-        SmallString<128> Insertion;
+        StringRef InsertPrefix = "";
+        SourceLocation InsertPos;
         bool AddComma = false;
-        if (!Ctor->getNumCtorInitializers() && FirstToCtorInits) {
-          SourceLocation BodyPos = Ctor->getBody()->getBeginLoc();
-          SourceLocation NextPos = Ctor->getBeginLoc();
-          do {
-            InsertPos = NextPos;
-            NextPos = Lexer::findNextToken(NextPos, *Result.SourceManager,
-                                           getLangOpts())
-                          ->getLocation();
-          } while (NextPos != BodyPos);
-          InsertPos = Lexer::getLocForEndOfToken(
-              InsertPos, 0, *Result.SourceManager, getLangOpts());
-
-          Insertion = " : ";
-        } else {
-          bool Found = false;
-          unsigned Index = Field->getFieldIndex();
-          for (const auto *Init : Ctor->inits()) {
-            if (Init->isMemberInitializer()) {
-              if (Index < Init->getMember()->getFieldIndex()) {
-                InsertPos = Init->getSourceLocation();
-                Found = true;
-                break;
-              }
-            }
-          }
-
-          if (!Found) {
-            if (Ctor->getNumCtorInitializers()) {
-              InsertPos = Lexer::getLocForEndOfToken(
-                  (*Ctor->init_rbegin())->getSourceRange().getEnd(), 0,
-                  *Result.SourceManager, getLangOpts());
-            }
-            Insertion = ", ";
+        bool InvalidFix = false;
+        const CXXCtorInitializer *LastInListInit = nullptr;
+        for (const CXXCtorInitializer *Init : Ctor->inits()) {
+          if (!Init->isWritten())
+            continue;
+          if (Init->isMemberInitializer() &&
+              Index < Init->getMember()->getFieldIndex()) {
+            // There are initializers after the one we are inserting, so add a
+            // comma after this insertion in order to not break anything.
+            AddComma = true;
+          LastInListInit = Init;
+        if (InsertPos.isInvalid()) {
+          if (LastInListInit) {
+                LastInListInit->getRParenLoc(), 0, *Result.SourceManager,
+                getLangOpts());
+            // Inserting after the last constructor initializer, so we need a
+            // comma.
+            InsertPrefix = ", ";
           } else {
-            AddComma = true;
-          }
-        }
-        Insertion.append(
-            {Field->getName(), "(",
+            InsertPos = Lexer::getLocForEndOfToken(
+                Ctor->getTypeSourceInfo()
+                    ->getTypeLoc()
+                    .getAs<clang::FunctionTypeLoc>()
+                    .getLocalRangeEnd(),
+                0, *Result.SourceManager, getLangOpts());
+
+            // If this is first time in the loop, there are no initializers so
+            // `:` declares member initialization list. If this is a subsequent
+            // pass then we have already inserted a `:` so continue with a
+            // comma.
+            InsertPrefix = FirstToCtorInits ? " : " : ", ";
+          }
+        }
+        InvalidFix |= InsertPos.isMacroID();
+
+        SourceLocation SemiColonEnd;
+        if (auto NextToken = Lexer::findNextToken(
+                S->getEndLoc(), *Result.SourceManager, getLangOpts()))
+          SemiColonEnd = NextToken->getEndLoc();
+        else
+          InvalidFix = true;
+
+        auto Diag =
+            diag(S->getBeginLoc(), "%0 should be initialized in a member"
+                                   " initializer of the constructor")
+            << Field;
+        if (!InvalidFix) {
+
+          CharSourceRange StmtRange =
+              CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
+          SmallString<128> Insertion(
+              {InsertPrefix, Field->getName(), "(",
                Lexer::getSourceText(
                    CharSourceRange(InitValue->getSourceRange(), true),
                    *Result.SourceManager, getLangOpts()),
                AddComma ? "), " : ")"});
-
-        SourceLocation SemiColonEnd =
-            Lexer::findNextToken(S->getEndLoc(), *Result.SourceManager,
-                                 getLangOpts())
-                ->getEndLoc();
-        CharSourceRange StmtRange =
-            CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
-
-        diag(S->getBeginLoc(), "%0 should be initialized in a member"
-                               " initializer of the constructor")
-            << Field
-            << FixItHint::CreateInsertion(InsertPos, Insertion,
+          Diag << FixItHint::CreateInsertion(InsertPos, Insertion,
                                              FirstToCtorInits)
                << FixItHint::CreateRemoval(StmtRange);
           FirstToCtorInits = false;
         }
       }
     }
   }
+}
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-prefer-member-initializer.cpp

Outside::Outside() {
     // CHECK-FIXES: Outside::Outside() : n(1), x(1.0) {
   n = 1;
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'n' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer]
     // CHECK-FIXES: {{^\ *$}}
   x = 1.0;
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'x' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer]
     // CHECK-FIXES: {{^\ *$}}
 }
+
+struct SafeDependancy {
+  int m;
+  int n;
+  SafeDependancy(int M) : m(M) {
+    // CHECK-FIXES: SafeDependancy(int M) : m(M), n(m) {
+    n = m;
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'n' should be initialized in a member initializer of the constructor
+  }
+  // We match against direct field dependancy as well as descendant field
+  // dependancy, ensure both are accounted for.
+  SafeDependancy(short M) : m(M) {
+    // CHECK-FIXES: SafeDependancy(short M) : m(M), n(m + 1) {
+    n = m + 1;
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'n' should be initialized in a member initializer of the constructor
+  }
+};
+
+struct BadDependancy {
+  int m;
+  int n;
+  BadDependancy(int N) : n(N) {
+    m = n;
+  }
+  BadDependancy(short N) : n(N) {
+    m = n + 1;
+  }
+};
+
+struct InitFromVarDecl {
+  int m;
+  InitFromVarDecl() {
+    // Can't apply this fix as n is declared in the body of the constructor.
+    int n = 3;
+    m = n;
+  }
+};
+
+struct AlreadyHasInit {
+  int m = 4;
+  AlreadyHasInit() {
+    m = 3;
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'm' should be initialized in a member initializer of the constructor
+  }
+};
+
+#define ASSIGN_IN_MACRO(FIELD, VALUE) FIELD = (VALUE);
+
+struct MacroCantFix {
+  int n; // NoFix
+  // CHECK-FIXES: int n; // NoFix
+  MacroCantFix() {
+    ASSIGN_IN_MACRO(n, 0)
+    // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: 'n' should be initialized in a member initializer of the constructor
+    // CHECK-FIXES: ASSIGN_IN_MACRO(n, 0)
+  }
+};