[NFC] Initialize class member pointers to nullptr.

[schittir]

Not sure what clang-format wants. I hope it likes this patch.

[owenpan]

In D153926#4456833, @schittir wrote:

Not sure what clang-format wants. I hope it likes this patch.

The clang-format part LGTM. Thanks!

[tahonermann]

These changes look find to me.

[schittir]

Thank you for reviewing. This patch is now landed.

clang/include/clang/AST/RawCommentList.h

public:
   /// Parse the comment, assuming it is attached to decl \c D.
   comments::FullComment *parse(const ASTContext &Context,
                                const Preprocessor *PP, const Decl *D) const;
 
 private:
   SourceRange Range;
 
   mutable StringRef RawText;
-  mutable const char *BriefText;
+  mutable const char *BriefText = nullptr;
 
   mutable bool RawTextValid : 1;   ///< True if RawText is valid
   mutable bool BriefTextValid : 1; ///< True if BriefText is valid
 
   unsigned Kind : 3;
 
   /// True if comment is attached to a declaration in ASTContext.
   bool IsAttached : 1;

clang/include/clang/AST/Redeclarable.h

public:
   /// Set the previous declaration. If PrevDecl is NULL, set this as the
   /// first and only declaration.
   void setPreviousDecl(decl_type *PrevDecl);
 
   /// Iterates through all the redeclarations of the same decl.
   class redecl_iterator {
     /// Current - The current declaration.
     decl_type *Current = nullptr;
-    decl_type *Starter;
+    decl_type *Starter = nullptr;
     bool PassedFirst = false;
 
   public:
     using value_type = decl_type *;
     using reference = decl_type *;
     using pointer = decl_type *;
     using iterator_category = std::forward_iterator_tag;
     using difference_type = std::ptrdiff_t;

clang/include/clang/CodeGen/CodeGenAction.h

public:
   /// The result may be null on failure.
   std::unique_ptr<llvm::Module> takeModule();
 
   /// Take the LLVM context used by this action.
   llvm::LLVMContext *takeLLVMContext();
 
   CodeGenerator *getCodeGenerator() const;
 
-  BackendConsumer *BEConsumer;
+  BackendConsumer *BEConsumer = nullptr;
 };
 
 class EmitAssemblyAction : public CodeGenAction {
   virtual void anchor();
 public:
   EmitAssemblyAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 

clang/include/clang/Sema/HLSLExternalSemaSource.h

 
 namespace clang {
 class NamespaceDecl;
 class Sema;
 
 class HLSLExternalSemaSource : public ExternalSemaSource {
   Sema *SemaPtr = nullptr;
   NamespaceDecl *HLSLNamespace = nullptr;
-  CXXRecordDecl *ResourceDecl;
+  CXXRecordDecl *ResourceDecl = nullptr;
 
   using CompletionFunction = std::function<void(CXXRecordDecl *)>;
   llvm::DenseMap<CXXRecordDecl *, CompletionFunction> Completions;
 
   void defineHLSLVectorAlias();
   void defineTrivialHLSLTypes();
   void forwardDeclareHLSLTypes();
 

clang/include/clang/Sema/Sema.h

void SetLateTemplateParser(LateTemplateParserCB *LTP,
     LateTemplateParser = LTP;
     LateTemplateParserCleanup = LTPCleanup;
     OpaqueParser = P;
   }
 
   class DelayedDiagnostics;
 
   class DelayedDiagnosticsState {
-    sema::DelayedDiagnosticPool *SavedPool;
+    sema::DelayedDiagnosticPool *SavedPool = nullptr;
     friend class Sema::DelayedDiagnostics;
   };
   typedef DelayedDiagnosticsState ParsingDeclState;
   typedef DelayedDiagnosticsState ProcessingContextState;
 
   /// A class which encapsulates the logic for delaying diagnostics
   /// during parsing and other processing.
   class DelayedDiagnostics {

clang/include/clang/Serialization/ModuleFile.h

public:
   /// user.
   bool DirectlyImported = false;
 
   /// The generation of which this module file is a part.
   unsigned Generation;
 
   /// The memory buffer that stores the data associated with
   /// this AST file, owned by the InMemoryModuleCache.
-  llvm::MemoryBuffer *Buffer;
+  llvm::MemoryBuffer *Buffer = nullptr;
 
   /// The size of this file, in bits.
   uint64_t SizeInBits = 0;
 
   /// The global bit offset (or base) of this module
   uint64_t GlobalBitOffset = 0;
 
   /// The bit offset of the AST block of this module.

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// CGBuilder insert helper. This function is called after an
   /// instruction is created using Builder.
   void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
                     llvm::BasicBlock *BB,
                     llvm::BasicBlock::iterator InsertPt) const;
 
   /// CurFuncDecl - Holds the Decl for the current outermost
   /// non-closure context.
-  const Decl *CurFuncDecl;
+  const Decl *CurFuncDecl = nullptr;
   /// CurCodeDecl - This is the inner-most code context, which includes blocks.
-  const Decl *CurCodeDecl;
-  const CGFunctionInfo *CurFnInfo;
+  const Decl *CurCodeDecl = nullptr;
+  const CGFunctionInfo *CurFnInfo = nullptr;
   QualType FnRetTy;
   llvm::Function *CurFn = nullptr;
 
   /// Save Parameter Decl for coroutine.
   llvm::SmallVector<const ParmVarDecl *, 4> FnArgs;
 
   // Holds coroutine data if the current function is a coroutine. We use a
   // wrapper to manage its lifetime, so that we don't have to define CGCoroData
class FinallyInfo {
     /// Where the catchall's edge through the cleanup should go.
     JumpDest RethrowDest;
 
     /// A function to call to enter the catch.
     llvm::FunctionCallee BeginCatchFn;
 
     /// An i1 variable indicating whether or not the @finally is
     /// running for an exception.
-    llvm::AllocaInst *ForEHVar;
+    llvm::AllocaInst *ForEHVar = nullptr;
 
     /// An i8* variable into which the exception pointer to rethrow
     /// has been saved.
-    llvm::AllocaInst *SavedExnVar;
+    llvm::AllocaInst *SavedExnVar = nullptr;
 
   public:
     void enter(CodeGenFunction &CGF, const Stmt *Finally,
                llvm::FunctionCallee beginCatchFn,
                llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn);
     void exit(CodeGenFunction &CGF);
   };
 

clang/lib/Format/SortJavaScriptImports.cpp

if (Err) {
       llvm::errs() << llvm::toString(std::move(Err)) << "\n";
       assert(false);
     }
 
     return {Result, 0};
   }
 
 private:
-  FormatToken *Current;
-  FormatToken *LineEnd;
+  FormatToken *Current = nullptr;
+  FormatToken *LineEnd = nullptr;
 
   FormatToken invalidToken;
 
   StringRef FileContents;
 
   void skipComments() { Current = skipComments(Current); }
 
   FormatToken *skipComments(FormatToken *Tok) {

clang/lib/Serialization/ASTReaderDecl.cpp

namespace clang {
   };
 
 } // namespace clang
 
 namespace {
 
 /// Iterator over the redeclarations of a declaration that have already
 /// been merged into the same redeclaration chain.
-template<typename DeclT>
-class MergedRedeclIterator {
-  DeclT *Start;
+template <typename DeclT> class MergedRedeclIterator {
+  DeclT *Start = nullptr;
   DeclT *Canonical = nullptr;
   DeclT *Current = nullptr;
 
 public:
   MergedRedeclIterator() = default;
   MergedRedeclIterator(DeclT *Start) : Start(Start), Current(Start) {}
 
   DeclT *operator*() { return Current; }

clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

bool ObjCDeallocChecker::diagnoseMistakenDealloc(SymbolRef DeallocedValue,
 
   C.emitReport(std::move(BR));
 
   return true;
 }
 
 ObjCDeallocChecker::ObjCDeallocChecker()
     : NSObjectII(nullptr), SenTestCaseII(nullptr), XCTestCaseII(nullptr),
-      CIFilterII(nullptr) {
+      Block_releaseII(nullptr), CIFilterII(nullptr) {
 
   MissingReleaseBugType.reset(
       new BugType(this, "Missing ivar release (leak)",
                   categories::MemoryRefCount));
 
   ExtraReleaseBugType.reset(
       new BugType(this, "Extra ivar release",
                   categories::MemoryRefCount));

clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp

 using namespace ento;
 
 namespace {
 class UncountedLambdaCapturesChecker
     : public Checker<check::ASTDecl<TranslationUnitDecl>> {
 private:
   BugType Bug{this, "Lambda capture of uncounted variable",
               "WebKit coding guidelines"};
-  mutable BugReporter *BR;
+  mutable BugReporter *BR = nullptr;
 
 public:
   void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR,
                     BugReporter &BRArg) const {
     BR = &BRArg;
 
     // The calls to checkAST* from AnalysisConsumer don't
     // visit template instantiations or lambda classes. We