ClangTidy check to flag uninitialized builtin and pointer fields.

[flx]

Summary

This patch is a continuation of http://reviews.llvm.org/D10553 by Jonathan B Coe.

The main additions are:

1. For C++11 the check suggests in-class field initialization as fix. This makes the fields future proof towards the addition of new constructors.
2. For older language versions the fields are added in the right position in the initializer list with more tests.
3. User documentation.

[jbcoe]

This looks good to me.

Fields initialised in constructors by being passed to methods by reference may be reported as false positives.

ie

void init(int& i);

struct A {
  int x;
  A() {
    init(x);
  }
};

I think it's going to be impossible to totally resolve this though as the body of initialisation functions may not be visible in the TU. False positives are better than silence in such cases.

[flx]

Removed unused include and changed casing on Builder variable.

[alexfh]

A high-level comment: I think, this comment still applies. I'm also slightly concerned about having this check in misc-, since the check isn't universally applicable (e.g. based on a couple of discussions, I guess LLVM community would likely not welcome this rule), but I'd like to leave misc- enabled by default. So moving the check to cppcoreguidelines- makes sense to me.

More substantial comments later.

[flx]

In D16517#336148, @alexfh wrote:

A high-level comment: I think, this comment still applies. I'm also slightly concerned about having this check in misc-, since the check isn't universally applicable (e.g. based on a couple of discussions, I guess LLVM community would likely not welcome this rule), but I'd like to leave misc- enabled by default. So moving the check to cppcoreguidelines- makes sense to me.

More substantial comments later.

Sounds good to me. If I'm reading the original comment correctly what's missing would be this part:

"Issue a diagnostic when constructing an object of a trivially constructible type without () or {} to initialize its members. To fix: Add () or {}. "

Is that correct?

Please let me know if that changes the name of the check and whether the next step should be moving the check or we'll do that after a detailed review of the specifics.

Thanks,
Felix

[flx]

Hi Alex,

could you take a look at the questions I posted in my last comment. Maybe there is some renaming work I can tackle while you review the change in more detail.

[alexfh]

In D16517#336157, @flx wrote:

In D16517#336148, @alexfh wrote:

A high-level comment: I think, this comment still applies. I'm also slightly concerned about having this check in misc-, since the check isn't universally applicable (e.g. based on a couple of discussions, I guess LLVM community would likely not welcome this rule), but I'd like to leave misc- enabled by default. So moving the check to cppcoreguidelines- makes sense to me.

More substantial comments later.

Sounds good to me. If I'm reading the original comment correctly what's missing would be this part:

"Issue a diagnostic when constructing an object of a trivially constructible type without () or {} to initialize its members. To fix: Add () or {}. "

Yes. I think, we might want to either add a separate check for this or make this part configurable. Adding a FIXME for now would be enough.

Please let me know if that changes the name of the check and whether the next step should be moving the check or we'll do that after a detailed review of the specifics.

I'd call the check cppcoreguidelines-pro-type-memberinit to be consistent with the anchor name of this rule used in the CppCoreGuidelines document (https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Pro-type-memberinit). These anchor names are usually short enough, but still quite descriptive, so it makes sense to use them when there are no significantly better alternatives.

clang-tidy/misc/UninitializedFieldCheck.cpp

29 ↗

(On Diff #45838)

Once you switch to SmallPtrSet, this should be changed to SmallPtrSetImpl&.

104 ↗

(On Diff #45838)

That's a self-assignment, basically. Just use Stream.flush() or put the Stream definition into a nested scope.

106 ↗

(On Diff #45838)

nit: No braces around single-line if/for bodies.

123 ↗

(On Diff #45838)

SmallVector?

124 ↗

(On Diff #45838)

.emplace_back(...)?

163 ↗

(On Diff #45838)

I'd make a local matcher for this and push this check to the matcher.

169 ↗

(On Diff #45838)

This should probably use SmallPtrSet.

170 ↗

(On Diff #45838)

Consider this as a simpler alternative with fewer dependencies:

for (const auto &Field : ParentClass->fields()) {
  if (fieldRequiresInit(Field))
    FieldsToInit.insert(Field);
}

Also, might be reasonable to expand the fieldRequiresInit function:

for (const auto &Field : ParentClass->fields()) {
  if (Field->getType()->isPointerType() || Field->getType()->isBuiltinType())
    FieldsToInit.insert(Field);
}

177 ↗

(On Diff #45838)

I think, this is superfluous. isMemberInitializer() should be enough.

181 ↗

(On Diff #45838)

The variable does not make code cleaner, please remove it.

199 ↗

(On Diff #45838)

nit: We don't use braces only for single-line if/for bodies. Same below.

207 ↗

(On Diff #45838)

s/Builder/Diag/, which is more common in this code.

208 ↗

(On Diff #45838)

No need to duplicate this code. Only the insertion of fixes should be conditional.

test/clang-tidy/misc-uninitialized-field.cpp

1 ↗

(On Diff #45838)

As usual: tests with templates and macros, please ;)

6 ↗

(On Diff #45838)

Also check that the constructor is left intact?

[flx]

Thanks for the review, Alex!

This is an intermediate updated patch that addresses your detailed comments. I'll rename the whole check in the next couple of days and will re-upload again.

[alexfh]

Looks good apart from renaming and one comment that's still relevant.

clang-tidy/misc/UninitializedFieldCheck.cpp

178 ↗

(On Diff #47159)

What about this? (relates to line 184 now)

[flx]

clang-tidy/misc/UninitializedFieldCheck.cpp

178 ↗

(On Diff #47159)

My comment on this was not submitted, just in case. Here it is again:

I think he idea is to return immediately if we're delegating to another constructor here. Am I misunderstanding the API call?

The important part is that we return in that case.

124 ↗

(On Diff #45838)

Gave a compile error. Probably because there is no explicit constructor with the 3 arguments.

177 ↗

(On Diff #45838)

I think he idea is to return immediately if we're delegating to another constructor here. Is this covered through some other check?

199 ↗

(On Diff #45838)

Done. This seems really subtle though when it depends on line length instead of single statement inside of loop.

test/clang-tidy/misc-uninitialized-field.cpp

1 ↗

(On Diff #45838)

Thanks for the reminder. Added early return for code inside of macros. Added template test which revealed I had to suppress the check inside of instantiated constructors.

[flx]

Renamed the check to: cppcoreguidelines-pro-type-member-init, note the extra dash between member and init to be consistent with the camelcase notation of the class name ProTypeMemberInitCheck.

[alexfh]

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

88 ↗

(On Diff #47280)

Maybe Lexer::getLocForEndOfToken?

94 ↗

(On Diff #47280)

Maybe Lexer::getLocForEndOfToken?

175 ↗

(On Diff #47280)

We still can output a warning, just be careful with fixits. Please also add a test for macros to illustrate the behavior. Two cases are interesting: code in a macro body and code in a macro argument.

205 ↗

(On Diff #47280)

Maybe Lexer::getLocForEndOfToken?

clang-tidy/misc/UninitializedFieldCheck.cpp

178 ↗

(On Diff #47159)

I see now. A comment explaining why this is done would be helpful here.

[flx]

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

205 ↗

(On Diff #47280)

Tried:

Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(),
                                 Field->getName().size(),
                                 Result.Context->getSourceManager(),
                                 Result.Context->getLangOpts()),

but that placed the {} before the field name:

• bool G /* with comment */;

+ bool {}G /* with comment */;

[flx]

Added comment that we're returning early if this constructor simply delegates to another constructor.

[alexfh]

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

206 ↗

(On Diff #47594)

IIUC what this is doing, the offset should be 0 instead of Field->getName().size(). I've tried Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0, *Result.SourceManager, Result.Context->getLangOpts()) and it seems to work fine on your tests.

test/clang-tidy/cppcoreguidelines-pro-type-member-init.cpp

96 ↗

(On Diff #47594)

We also need to check that the macro definition stays the same. The lack of CHECK-FIXES doesn't ensure the fix wasn't applied (probably, it should, but that's another story).

[flx]

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

206 ↗

(On Diff #47594)

Great, that worked.

[alexfh]

Looks good! Thank you for the new awesome check and to Jonathan for the original patch!

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyCppCoreGuidelinesModule
   CppCoreGuidelinesTidyModule.cpp
   ProBoundsArrayToPointerDecayCheck.cpp
   ProBoundsConstantArrayIndexCheck.cpp
   ProBoundsPointerArithmeticCheck.cpp
   ProTypeConstCastCheck.cpp
   ProTypeCstyleCastCheck.cpp
+  ProTypeMemberInitCheck.cpp
   ProTypeReinterpretCastCheck.cpp
   ProTypeStaticCastDowncastCheck.cpp
   ProTypeUnionAccessCheck.cpp
   ProTypeVarargCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyMiscModule
   clangTidyUtils
   clangTooling
   )

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../misc/AssignOperatorSignatureCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
 #include "ProBoundsConstantArrayIndexCheck.h"
 #include "ProBoundsPointerArithmeticCheck.h"
 #include "ProTypeConstCastCheck.h"
 #include "ProTypeCstyleCastCheck.h"
+#include "ProTypeMemberInitCheck.h"
 #include "ProTypeReinterpretCastCheck.h"
 #include "ProTypeStaticCastDowncastCheck.h"
 #include "ProTypeUnionAccessCheck.h"
 #include "ProTypeVarargCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
         "cppcoreguidelines-pro-bounds-array-to-pointer-decay");
     CheckFactories.registerCheck<ProBoundsConstantArrayIndexCheck>(
         "cppcoreguidelines-pro-bounds-constant-array-index");
     CheckFactories.registerCheck<ProBoundsPointerArithmeticCheck>(
         "cppcoreguidelines-pro-bounds-pointer-arithmetic");
     CheckFactories.registerCheck<ProTypeConstCastCheck>(
         "cppcoreguidelines-pro-type-const-cast");
     CheckFactories.registerCheck<ProTypeCstyleCastCheck>(
         "cppcoreguidelines-pro-type-cstyle-cast");
+    CheckFactories.registerCheck<ProTypeMemberInitCheck>(
+        "cppcoreguidelines-pro-type-member-init");
     CheckFactories.registerCheck<ProTypeReinterpretCastCheck>(
         "cppcoreguidelines-pro-type-reinterpret-cast");
     CheckFactories.registerCheck<ProTypeStaticCastDowncastCheck>(
         "cppcoreguidelines-pro-type-static-cast-downcast");
     CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
         "cppcoreguidelines-pro-type-union-access");
     CheckFactories.registerCheck<ProTypeVarargCheck>(
         "cppcoreguidelines-pro-type-vararg");

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.h

+//===--- ProTypeMemberInitCheck.h - clang-tidy-------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+/// \brief Checks that builtin or pointer fields are initialized by
+/// user-defined constructors.
+///
+/// Members initialized through function calls in the body of the constructor
+/// will result in false positives.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-member-init.html
+/// TODO: See if 'fixes' for false positives are optimized away by the compiler.
+/// TODO: "Issue a diagnostic when constructing an object of a trivially
+/// constructible type without () or {} to initialize its members. To fix: Add
+/// () or {}."
+class ProTypeMemberInitCheck : public ClangTidyCheck {
+public:
+  ProTypeMemberInitCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

+//===--- ProTypeMemberInitCheck.cpp - clang-tidy---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ProTypeMemberInitCheck.h"
+#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include "llvm/ADT/SmallPtrSet.h"
+
+using namespace clang::ast_matchers;
+using llvm::SmallPtrSet;
+using llvm::SmallPtrSetImpl;
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+namespace {
+
+AST_MATCHER(CXXConstructorDecl, isUserProvided) {
+  return Node.isUserProvided();
+}
+
+static void
+fieldsRequiringInit(const RecordDecl::field_range &Fields,
+                    SmallPtrSetImpl<const FieldDecl *> &FieldsToInit) {
+  for (const FieldDecl *F : Fields) {
+    QualType Type = F->getType();
+    if (Type->isPointerType() || Type->isBuiltinType())
+      FieldsToInit.insert(F);
+  }
+}
+
+void removeFieldsInitializedInBody(
+    const Stmt &Stmt, ASTContext &Context,
+    SmallPtrSetImpl<const FieldDecl *> &FieldDecls) {
+  auto Matches =
+      match(findAll(binaryOperator(
+                hasOperatorName("="),
+                hasLHS(memberExpr(member(fieldDecl().bind("fieldDecl")))))),
+            Stmt, Context);
+  for (const auto &Match : Matches)
+    FieldDecls.erase(Match.getNodeAs<FieldDecl>("fieldDecl"));
+}
+
+// Creates comma separated list of fields requiring initialization in order of
+// declaration.
+std::string toCommaSeparatedString(
+    const RecordDecl::field_range &FieldRange,
+    const SmallPtrSetImpl<const FieldDecl *> &FieldsRequiringInit) {
+  std::string List;
+  llvm::raw_string_ostream Stream(List);
+  size_t AddedFields = 0;
+  for (const FieldDecl *Field : FieldRange) {
+    if (FieldsRequiringInit.count(Field) > 0) {
+      Stream << Field->getName();
+      if (++AddedFields < FieldsRequiringInit.size())
+        Stream << ", ";
+    }
+  }
+  return Stream.str();
+}
+
+// Contains all fields in correct order that need to be inserted at the same
+// location for pre C++11.
+// There are 3 kinds of insertions:
+// 1. The fields are inserted after an existing CXXCtorInitializer stored in
+// InitializerBefore. This will be the case whenever there is a written
+// initializer before the fields available.
+// 2. The fields are inserted before the first existing initializer stored in
+// InitializerAfter.
+// 3. There are no written initializers and the fields will be inserted before
+// the constructor's body creating a new initializer list including the ':'.
+struct FieldsInsertion {
+  const CXXCtorInitializer *InitializerBefore;
+  const CXXCtorInitializer *InitializerAfter;
+  SmallVector<const FieldDecl *, 4> Fields;
+
+  SourceLocation getLocation(const ASTContext &Context,
+                             const CXXConstructorDecl &Constructor) const {
+    if (InitializerBefore != nullptr) {
+      return Lexer::getLocForEndOfToken(InitializerBefore->getRParenLoc(), 0,
+                                        Context.getSourceManager(),
+                                        Context.getLangOpts());
+    }
+    auto StartLocation = InitializerAfter != nullptr
+                             ? InitializerAfter->getSourceRange().getBegin()
+                             : Constructor.getBody()->getLocStart();
+    auto Token =
+        lexer_utils::getPreviousNonCommentToken(Context, StartLocation);
+    return Lexer::getLocForEndOfToken(Token.getLocation(), 0,
+                                      Context.getSourceManager(),
+                                      Context.getLangOpts());
+  }
+
+  std::string codeToInsert() const {
+    assert(!Fields.empty() && "No fields to insert");
+    std::string Code;
+    llvm::raw_string_ostream Stream(Code);
+    // Code will be inserted before the first written initializer after ':',
+    // append commas.
+    if (InitializerAfter != nullptr) {
+      for (const auto *Field : Fields)
+        Stream << " " << Field->getName() << "(),";
+    } else {
+      // The full initializer list is created, add extra space after
+      // constructor's rparens.
+      if (InitializerBefore == nullptr)
+        Stream << " ";
+      for (const auto *Field : Fields)
+        Stream << ", " << Field->getName() << "()";
+    }
+    Stream.flush();
+    // The initializer list is created, replace leading comma with colon.
+    if (InitializerBefore == nullptr && InitializerAfter == nullptr)
+      Code[1] = ':';
+    return Code;
+  }
+};
+
+SmallVector<FieldsInsertion, 16> computeInsertions(
+    const CXXConstructorDecl::init_const_range &Inits,
+    const RecordDecl::field_range &Fields,
+    const SmallPtrSetImpl<const FieldDecl *> &FieldsRequiringInit) {
+  // Find last written non-member initializer or null.
+  const CXXCtorInitializer *LastWrittenNonMemberInit = nullptr;
+  for (const CXXCtorInitializer *Init : Inits) {
+    if (Init->isWritten() && !Init->isMemberInitializer())
+      LastWrittenNonMemberInit = Init;
+  }
+  SmallVector<FieldsInsertion, 16> OrderedFields;
+  OrderedFields.push_back({LastWrittenNonMemberInit, nullptr, {}});
+
+  auto CurrentField = Fields.begin();
+  for (const CXXCtorInitializer *Init : Inits) {
+    if (Init->isWritten() && Init->isMemberInitializer()) {
+      const FieldDecl *MemberField = Init->getMember();
+      // Add all fields between current field and this member field the previous
+      // FieldsInsertion if the field requires initialization.
+      for (; CurrentField != Fields.end() && *CurrentField != MemberField;
+           ++CurrentField) {
+        if (FieldsRequiringInit.count(*CurrentField) > 0)
+          OrderedFields.back().Fields.push_back(*CurrentField);
+      }
+      // If this is the first written member initializer and there was no
+      // written non-member initializer set this initializer as
+      // InitializerAfter.
+      if (OrderedFields.size() == 1 &&
+          OrderedFields.back().InitializerBefore == nullptr)
+        OrderedFields.back().InitializerAfter = Init;
+      OrderedFields.push_back({Init, nullptr, {}});
+    }
+  }
+  // Add remaining fields that require initialization to last FieldsInsertion.
+  for (; CurrentField != Fields.end(); ++CurrentField) {
+    if (FieldsRequiringInit.count(*CurrentField) > 0)
+      OrderedFields.back().Fields.push_back(*CurrentField);
+  }
+  return OrderedFields;
+}
+
+} // namespace
+
+void ProTypeMemberInitCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(cxxConstructorDecl(isDefinition(), isUserProvided(),
+                                        unless(isInstantiated()))
+                         .bind("ctor"),
+                     this);
+}
+
+void ProTypeMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
+  const auto &MemberFields = Ctor->getParent()->fields();
+
+  SmallPtrSet<const FieldDecl *, 16> FieldsToInit;
+  fieldsRequiringInit(MemberFields, FieldsToInit);
+  if (FieldsToInit.empty())
+    return;
+
+  for (CXXCtorInitializer *Init : Ctor->inits()) {
+    // Return early if this constructor simply delegates to another constructor
+    // in the same class.
+    if (Init->isDelegatingInitializer())
+      return;
+    if (!Init->isMemberInitializer())
+      continue;
+    FieldsToInit.erase(Init->getMember());
+  }
+  removeFieldsInitializedInBody(*Ctor->getBody(), *Result.Context,
+                                FieldsToInit);
+  if (FieldsToInit.empty())
+    return;
+
+  DiagnosticBuilder Diag =
+      diag(Ctor->getLocStart(),
+           "constructor does not initialize these built-in/pointer fields: %0")
+      << toCommaSeparatedString(MemberFields, FieldsToInit);
+  // Do not propose fixes in macros since we cannot place them correctly.
+  if (Ctor->getLocStart().isMacroID())
+    return;
+  // For C+11 use in-class initialization which covers all future constructors
+  // as well.
+  if (Result.Context->getLangOpts().CPlusPlus11) {
+    for (const auto *Field : FieldsToInit) {
+      Diag << FixItHint::CreateInsertion(
+          Lexer::getLocForEndOfToken(Field->getSourceRange().getEnd(), 0,
+                                     Result.Context->getSourceManager(),
+                                     Result.Context->getLangOpts()),
+          "{}");
+    }
+    return;
+  }
+  for (const auto &FieldsInsertion :
+       computeInsertions(Ctor->inits(), MemberFields, FieldsToInit)) {
+    if (!FieldsInsertion.Fields.empty())
+      Diag << FixItHint::CreateInsertion(
+          FieldsInsertion.getLocation(*Result.Context, *Ctor),
+          FieldsInsertion.codeToInsert());
+  }
+}
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/docs/clang-tidy/checks/cppcoreguidelines-pro-type-member-init.rst

+.. title:: clang-tidy - cppcoreguidelines-pro-type-member-init
+
+cppcoreguidelines-pro-type-member-init
+======================================
+
+The check flags user-defined constructor definitions that do not initialize all
+builtin and pointer fields which leaves their memory in an undefined state.
+
+For C++11 it suggests fixes to add in-class field initializers. For older
+versions it inserts the field initializers into the constructor initializer
+list.
+
+The check takes assignment of fields in the constructor body into account but
+generates false positives for fields initialized in methods invoked in the
+constructor body.
+
+This rule is part of the "Type safety" profile of the C++ Core Guidelines, see
+https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Pro-type-memberinit.

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

.. toctree::
    cert-err61-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err61-cpp>
    cert-fio38-c (redirects to misc-non-copyable-objects) <cert-fio38-c>
    cert-oop11-cpp (redirects to misc-move-constructor-init) <cert-oop11-cpp>
    cppcoreguidelines-pro-bounds-array-to-pointer-decay
    cppcoreguidelines-pro-bounds-constant-array-index
    cppcoreguidelines-pro-bounds-pointer-arithmetic
    cppcoreguidelines-pro-type-const-cast
    cppcoreguidelines-pro-type-cstyle-cast
+   cppcoreguidelines-pro-type-member-init
    cppcoreguidelines-pro-type-reinterpret-cast
    cppcoreguidelines-pro-type-static-cast-downcast
    cppcoreguidelines-pro-type-union-access
    cppcoreguidelines-pro-type-vararg
    google-build-explicit-make-pair
    google-build-namespaces
    google-build-using-namespace
    google-explicit-constructor

clang-tools-extra/trunk/test/clang-tidy/cppcoreguidelines-pro-type-member-init-cxx98.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -- -std=c++98
+
+struct PositiveFieldBeforeConstructor {
+  int F;
+  PositiveFieldBeforeConstructor() /* some comment */ {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: F
+  // CHECK-FIXES: PositiveFieldBeforeConstructor() : F() /* some comment */ {}
+};
+
+struct PositiveFieldAfterConstructor {
+  PositiveFieldAfterConstructor() {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: F, G, H
+  // CHECK-FIXES: PositiveFieldAfterConstructor() : F(), G(), H() {}
+  int F;
+  bool G /* with comment */;
+  int *H;
+  PositiveFieldBeforeConstructor IgnoredField;
+};
+
+struct PositiveSeparateDefinition {
+  PositiveSeparateDefinition();
+  int F;
+};
+
+PositiveSeparateDefinition::PositiveSeparateDefinition() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: constructor does not initialize these built-in/pointer fields: F
+// CHECK-FIXES: PositiveSeparateDefinition::PositiveSeparateDefinition() : F() {}
+
+struct PositiveMixedFieldOrder {
+  PositiveMixedFieldOrder() : /* some comment */ J(0), L(0), M(0) {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: I, K, N
+  // CHECK-FIXES: PositiveMixedFieldOrder() : I(), /* some comment */ J(0), K(), L(0), M(0), N() {}
+  int I;
+  int J;
+  int K;
+  int L;
+  int M;
+  int N;
+};
+
+struct PositiveAfterBaseInitializer : public PositiveMixedFieldOrder {
+  PositiveAfterBaseInitializer() : PositiveMixedFieldOrder() {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: F
+  // CHECK-FIXES: PositiveAfterBaseInitializer() : PositiveMixedFieldOrder(), F() {}
+  int F;
+};
+
+struct NegativeFieldInitialized {
+  int F;
+
+  NegativeFieldInitialized() : F() {}
+};
+
+struct NegativeFieldInitializedInDefinition {
+  int F;
+
+  NegativeFieldInitializedInDefinition();
+};
+
+NegativeFieldInitializedInDefinition::NegativeFieldInitializedInDefinition() : F() {}
+
+struct NegativeInitializedInBody {
+  NegativeInitializedInBody() { I = 0; }
+  int I;
+};
+
+

clang-tools-extra/trunk/test/clang-tidy/cppcoreguidelines-pro-type-member-init.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t
+
+struct PositiveFieldBeforeConstructor {
+  int F;
+  // CHECK-FIXES: int F{};
+  PositiveFieldBeforeConstructor() {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: F
+  // CHECK-FIXES: PositiveFieldBeforeConstructor() {}
+};
+
+struct PositiveFieldAfterConstructor {
+  PositiveFieldAfterConstructor() {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: F, G
+  // CHECK-FIXES: PositiveFieldAfterConstructor() {}
+  int F;
+  // CHECK-FIXES: int F{};
+  bool G /* with comment */;
+  // CHECK-FIXES: bool G{} /* with comment */;
+  PositiveFieldBeforeConstructor IgnoredField;
+};
+
+struct PositiveSeparateDefinition {
+  PositiveSeparateDefinition();
+  int F;
+  // CHECK-FIXES: int F{};
+};
+
+PositiveSeparateDefinition::PositiveSeparateDefinition() {}
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: constructor does not initialize these built-in/pointer fields: F
+// CHECK-FIXES: PositiveSeparateDefinition::PositiveSeparateDefinition() {}
+
+struct PositiveMixedFieldOrder {
+  PositiveMixedFieldOrder() : J(0) {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: I, K
+  // CHECK-FIXES: PositiveMixedFieldOrder() : J(0) {}
+  int I;
+  // CHECK-FIXES: int I{};
+  int J;
+  int K;
+  // CHECK-FIXES: int K{};
+};
+
+template <typename T>
+struct Template {
+  Template() {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these built-in/pointer fields: F
+  int F;
+  // CHECK-FIXES: int F{};
+  T T1;
+  // CHECK-FIXES: T T1;
+};
+
+void instantiate() {
+  Template<int> TInt;
+}
+
+struct NegativeFieldInitialized {
+  int F;
+
+  NegativeFieldInitialized() : F() {}
+};
+
+struct NegativeFieldInitializedInDefinition {
+  int F;
+
+  NegativeFieldInitializedInDefinition();
+};
+NegativeFieldInitializedInDefinition::NegativeFieldInitializedInDefinition() : F() {}
+
+
+struct NegativeInClassInitialized {
+  int F = 0;
+
+  NegativeInClassInitialized() {}
+};
+
+struct NegativeConstructorDelegated {
+  int F;
+
+  NegativeConstructorDelegated(int F) : F(F) {}
+  NegativeConstructorDelegated() : NegativeConstructorDelegated(0) {}
+};
+
+struct NegativeInitializedInBody {
+  NegativeInitializedInBody() { I = 0; }
+  int I;
+};
+
+#define UNINITIALIZED_FIELD_IN_MACRO_BODY(FIELD) \
+  struct UninitializedField##FIELD {     \
+    UninitializedField##FIELD() {}     \
+    int FIELD;           \
+  };             \
+// Ensure FIELD is not initialized since fixes inside of macros are disabled.
+// CHECK-FIXES: int FIELD;
+
+UNINITIALIZED_FIELD_IN_MACRO_BODY(F);
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: constructor does not initialize these built-in/pointer fields: F
+UNINITIALIZED_FIELD_IN_MACRO_BODY(G);
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: constructor does not initialize these built-in/pointer fields: G
+
+#define UNINITIALIZED_FIELD_IN_MACRO_ARGUMENT(ARGUMENT) \
+  ARGUMENT            \
+
+UNINITIALIZED_FIELD_IN_MACRO_ARGUMENT(struct UninitializedFieldInMacroArg {
+  UninitializedFieldInMacroArg() {}
+  int Field;
+});
+// CHECK-MESSAGES: :[[@LINE-3]]:3: warning: constructor does not initialize these built-in/pointer fields: Field
+// Ensure FIELD is not initialized since fixes inside of macros are disabled.
+// CHECK-FIXES: int Field;