From 4f233181183ca5bfd8868022c0f748a69a6efce4 Mon Sep 17 00:00:00 2001 From: Eugene Zelenko Date: Thu, 22 Mar 2018 00:53:26 +0000 Subject: [PATCH] [Frontend] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 328171 --- clang/include/clang/Frontend/ASTUnit.h | 121 +++++----- clang/include/clang/Frontend/DiagnosticRenderer.h | 22 +- .../clang/Frontend/FrontendPluginRegistry.h | 12 +- .../include/clang/Frontend/TextDiagnosticBuffer.h | 32 +-- .../clang/Frontend/VerifyDiagnosticConsumer.h | 60 ++--- clang/lib/Frontend/ASTUnit.cpp | 254 ++++++++++++--------- clang/lib/Frontend/DiagnosticRenderer.cpp | 71 +++--- clang/lib/Frontend/TextDiagnosticBuffer.cpp | 21 +- clang/lib/Frontend/VerifyDiagnosticConsumer.cpp | 123 ++++++---- 9 files changed, 417 insertions(+), 299 deletions(-) diff --git a/clang/include/clang/Frontend/ASTUnit.h b/clang/include/clang/Frontend/ASTUnit.h index 5d04dcd..49c0da4 100644 --- a/clang/include/clang/Frontend/ASTUnit.h +++ b/clang/include/clang/Frontend/ASTUnit.h @@ -1,4 +1,4 @@ -//===--- ASTUnit.h - ASTUnit utility ----------------------------*- C++ -*-===// +//===- ASTUnit.h - ASTUnit utility ------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -16,8 +16,11 @@ #include "clang-c/Index.h" #include "clang/AST/ASTContext.h" +#include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileSystemOptions.h" +#include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetOptions.h" #include "clang/Lex/HeaderSearchOptions.h" @@ -26,48 +29,59 @@ #include "clang/Sema/CodeCompleteConsumer.h" #include "clang/Serialization/ASTBitCodes.h" #include "clang/Frontend/PrecompiledPreamble.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" +#include "llvm/ADT/None.h" +#include "llvm/ADT/Optional.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" -#include "llvm/Support/MD5.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/iterator_range.h" #include +#include +#include #include #include -#include #include #include namespace llvm { - class MemoryBuffer; -} + +class MemoryBuffer; + +} // namespace llvm namespace clang { -class Sema; + class ASTContext; +class ASTDeserializationListener; +class ASTMutationListener; class ASTReader; -class CompilerInvocation; class CompilerInstance; +class CompilerInvocation; class Decl; -class DiagnosticsEngine; class FileEntry; class FileManager; +class FrontendAction; class HeaderSearch; class InputKind; class MemoryBufferCache; -class Preprocessor; -class PreprocessorOptions; class PCHContainerOperations; class PCHContainerReader; +class Preprocessor; +class PreprocessorOptions; +class Sema; class TargetInfo; -class FrontendAction; -class ASTDeserializationListener; namespace vfs { + class FileSystem; -} + +} // namespace vfs /// \brief Utility class for loading a ASTContext from an AST file. -/// class ASTUnit { public: struct StandaloneFixIt { @@ -83,7 +97,7 @@ public: std::string Message; std::string Filename; unsigned LocOffset; - std::vector > Ranges; + std::vector> Ranges; std::vector FixIts; }; @@ -101,7 +115,7 @@ private: std::shared_ptr HSOpts; std::shared_ptr PPOpts; IntrusiveRefCntPtr Reader; - bool HadModuleLoaderFatalFailure; + bool HadModuleLoaderFatalFailure = false; struct ASTWriterData; std::unique_ptr WriterData; @@ -126,22 +140,22 @@ private: // OnlyLocalDecls - when true, walking this AST should only visit declarations // that come from the AST itself, not from included precompiled headers. // FIXME: This is temporary; eventually, CIndex will always do this. - bool OnlyLocalDecls; + bool OnlyLocalDecls = false; /// \brief Whether to capture any diagnostics produced. - bool CaptureDiagnostics; + bool CaptureDiagnostics = false; /// \brief Track whether the main file was loaded from an AST or not. bool MainFileIsAST; /// \brief What kind of translation unit this AST represents. - TranslationUnitKind TUKind; + TranslationUnitKind TUKind = TU_Complete; /// \brief Whether we should time each operation. bool WantTiming; /// \brief Whether the ASTUnit should delete the remapped buffers. - bool OwnsRemappedFileBuffers; + bool OwnsRemappedFileBuffers = true; /// Track the top-level decls which appeared in an ASTUnit which was loaded /// from a source file. @@ -153,8 +167,8 @@ private: std::vector TopLevelDecls; /// \brief Sorted (by file offset) vector of pairs of file offset/Decl. - typedef SmallVector, 64> LocDeclsTy; - typedef llvm::DenseMap FileDeclsTy; + using LocDeclsTy = SmallVector, 64>; + using FileDeclsTy = llvm::DenseMap; /// \brief Map from FileID to the file-level declarations that it contains. /// The files and decls are only local (and non-preamble) ones. @@ -179,7 +193,7 @@ private: /// /// Diagnostics that come from the driver are retained from one parse to /// the next. - unsigned NumStoredDiagnosticsFromDriver; + unsigned NumStoredDiagnosticsFromDriver = 0; /// \brief Counter that determines when we want to try building a /// precompiled preamble. @@ -190,7 +204,7 @@ private: /// we'll attempt to rebuild the precompiled header. This way, if /// building the precompiled preamble fails, we won't try again for /// some number of calls. - unsigned PreambleRebuildCounter; + unsigned PreambleRebuildCounter = 0; /// \brief Cache pairs "filename - source location" /// @@ -200,7 +214,6 @@ private: /// of that loading. It must be cleared when preamble is recreated. llvm::StringMap PreambleSrcLocCache; -private: /// The contents of the preamble. llvm::Optional Preamble; @@ -215,7 +228,7 @@ private: /// object when re-using the precompiled preamble. Note that only the /// number of warnings matters, since we will not save the preamble /// when any errors are present. - unsigned NumWarningsInPreamble; + unsigned NumWarningsInPreamble = 0; /// \brief A list of the serialization ID numbers for each of the top-level /// declarations parsed within the precompiled preamble. @@ -283,7 +296,7 @@ public: /// \brief Retrieve the mapping from formatted type names to unique type /// identifiers. - llvm::StringMap &getCachedCompletionTypes() { + llvm::StringMap &getCachedCompletionTypes() { return CachedCompletionTypes; } @@ -318,18 +331,18 @@ private: /// /// This hash value is used to determine when we need to refresh the /// global code-completion cache. - unsigned CompletionCacheTopLevelHashValue; + unsigned CompletionCacheTopLevelHashValue = 0; /// \brief A string hash of the top-level declaration and macro definition /// names processed the last time that we reparsed the precompiled preamble. /// /// This hash value is used to determine when we need to refresh the /// global code-completion cache after a rebuild of the precompiled preamble. - unsigned PreambleTopLevelHashValue; + unsigned PreambleTopLevelHashValue = 0; /// \brief The current hash value for the top-level declaration and macro /// definition names - unsigned CurrentTopLevelHashValue; + unsigned CurrentTopLevelHashValue = 0; /// \brief Bit used by CIndex to mark when a translation unit may be in an /// inconsistent state, and is not safe to free. @@ -342,9 +355,6 @@ private: /// \brief Clear out and deallocate void ClearCachedCompletionResults(); - ASTUnit(const ASTUnit &) = delete; - void operator=(const ASTUnit &) = delete; - explicit ASTUnit(bool MainFileIsAST); bool Parse(std::shared_ptr PCHContainerOps, @@ -382,21 +392,23 @@ private: ConcurrencyState ConcurrencyCheckValue; public: + friend class ConcurrencyCheck; + class ConcurrencyCheck { ASTUnit &Self; public: - explicit ConcurrencyCheck(ASTUnit &Self) - : Self(Self) - { + explicit ConcurrencyCheck(ASTUnit &Self) : Self(Self) { Self.ConcurrencyCheckValue.start(); } + ~ConcurrencyCheck() { Self.ConcurrencyCheckValue.finish(); } }; - friend class ConcurrencyCheck; + ASTUnit(const ASTUnit &) = delete; + ASTUnit &operator=(const ASTUnit &) = delete; ~ASTUnit(); bool isMainFileAST() const { return MainFileIsAST; } @@ -405,22 +417,23 @@ public: void setUnsafeToFree(bool Value) { UnsafeToFree = Value; } const DiagnosticsEngine &getDiagnostics() const { return *Diagnostics; } - DiagnosticsEngine &getDiagnostics() { return *Diagnostics; } + DiagnosticsEngine &getDiagnostics() { return *Diagnostics; } const SourceManager &getSourceManager() const { return *SourceMgr; } - SourceManager &getSourceManager() { return *SourceMgr; } + SourceManager &getSourceManager() { return *SourceMgr; } const Preprocessor &getPreprocessor() const { return *PP; } - Preprocessor &getPreprocessor() { return *PP; } + Preprocessor &getPreprocessor() { return *PP; } std::shared_ptr getPreprocessorPtr() const { return PP; } const ASTContext &getASTContext() const { return *Ctx; } - ASTContext &getASTContext() { return *Ctx; } + ASTContext &getASTContext() { return *Ctx; } void setASTContext(ASTContext *ctx) { Ctx = ctx; } void setPreprocessor(std::shared_ptr pp); bool hasSema() const { return (bool)TheSema; } + Sema &getSema() const { assert(TheSema && "ASTUnit does not have a Sema object!"); return *TheSema; @@ -442,7 +455,7 @@ public: } const FileManager &getFileManager() const { return *FileMgr; } - FileManager &getFileManager() { return *FileMgr; } + FileManager &getFileManager() { return *FileMgr; } const FileSystemOptions &getFileSystemOpts() const { return FileSystemOpts; } @@ -465,7 +478,7 @@ public: /// \brief If this ASTUnit came from an AST file, returns the filename for it. StringRef getASTFileName() const; - typedef std::vector::iterator top_level_iterator; + using top_level_iterator = std::vector::iterator; top_level_iterator top_level_begin() { assert(!isMainFileAST() && "Invalid call for AST based ASTUnit!"); @@ -549,20 +562,25 @@ public: } // Retrieve the diagnostics associated with this AST - typedef StoredDiagnostic *stored_diag_iterator; - typedef const StoredDiagnostic *stored_diag_const_iterator; + using stored_diag_iterator = StoredDiagnostic *; + using stored_diag_const_iterator = const StoredDiagnostic *; + stored_diag_const_iterator stored_diag_begin() const { return StoredDiagnostics.begin(); } + stored_diag_iterator stored_diag_begin() { return StoredDiagnostics.begin(); } + stored_diag_const_iterator stored_diag_end() const { return StoredDiagnostics.end(); } + stored_diag_iterator stored_diag_end() { return StoredDiagnostics.end(); } + unsigned stored_diag_size() const { return StoredDiagnostics.size(); } stored_diag_iterator stored_diag_afterDriver_begin() { @@ -571,8 +589,8 @@ public: return StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver; } - typedef std::vector::iterator - cached_completion_iterator; + using cached_completion_iterator = + std::vector::iterator; cached_completion_iterator cached_completion_begin() { return CachedCompletionResults.begin(); @@ -594,7 +612,7 @@ public: /// \brief Type for a function iterating over a number of declarations. /// \returns true to continue iteration and false to abort. - typedef bool (*DeclVisitorFn)(void *context, const Decl *D); + using DeclVisitorFn = bool (*)(void *context, const Decl *D); /// \brief Iterate over local declarations (locally parsed if this is a parsed /// source file or the loaded declarations of the primary module if this is an @@ -620,7 +638,7 @@ public: /// \brief A mapping from a file name to the memory buffer that stores the /// remapped contents of that file. - typedef std::pair RemappedFile; + using RemappedFile = std::pair; /// \brief Create a ASTUnit. Gets ownership of the passed CompilerInvocation. static std::unique_ptr @@ -631,8 +649,10 @@ public: enum WhatToLoad { /// Load options and the preprocessor state. LoadPreprocessorOnly, + /// Load the AST, but do not restore Sema state. LoadASTOnly, + /// Load everything, including Sema. LoadEverything }; @@ -676,7 +696,6 @@ private: IntrusiveRefCntPtr VFS); public: - /// \brief Create an ASTUnit from a source file, via a CompilerInvocation /// object, by invoking the optionally provided ASTFrontendAction. /// @@ -853,4 +872,4 @@ public: } // namespace clang -#endif +#endif // LLVM_CLANG_FRONTEND_ASTUNIT_H diff --git a/clang/include/clang/Frontend/DiagnosticRenderer.h b/clang/include/clang/Frontend/DiagnosticRenderer.h index e453d7d..0814569 100644 --- a/clang/include/clang/Frontend/DiagnosticRenderer.h +++ b/clang/include/clang/Frontend/DiagnosticRenderer.h @@ -1,4 +1,4 @@ -//===--- DiagnosticRenderer.h - Diagnostic Pretty-Printing ------*- C++ -*-===// +//===- DiagnosticRenderer.h - Diagnostic Pretty-Printing --------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -17,18 +17,21 @@ #define LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H #include "clang/Basic/Diagnostic.h" +#include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/PointerUnion.h" +#include "llvm/ADT/StringRef.h" namespace clang { -class DiagnosticOptions; class LangOptions; class SourceManager; -typedef llvm::PointerUnion DiagOrStoredDiag; +using DiagOrStoredDiag = + llvm::PointerUnion; /// \brief Class to encapsulate the logic for formatting a diagnostic message. /// @@ -64,7 +67,7 @@ protected: /// /// The level of the last diagnostic emitted. Used to detect level changes /// which change the amount of information displayed. - DiagnosticsEngine::Level LastLevel; + DiagnosticsEngine::Level LastLevel = DiagnosticsEngine::Ignored; DiagnosticRenderer(const LangOptions &LangOpts, DiagnosticOptions *DiagOpts); @@ -97,7 +100,6 @@ protected: virtual void endDiagnostic(DiagOrStoredDiag D, DiagnosticsEngine::Level Level) {} - private: void emitBasicNote(StringRef Message); void emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc, @@ -142,7 +144,7 @@ class DiagnosticNoteRenderer : public DiagnosticRenderer { public: DiagnosticNoteRenderer(const LangOptions &LangOpts, DiagnosticOptions *DiagOpts) - : DiagnosticRenderer(LangOpts, DiagOpts) {} + : DiagnosticRenderer(LangOpts, DiagOpts) {} ~DiagnosticNoteRenderer() override; @@ -156,5 +158,7 @@ public: virtual void emitNote(FullSourceLoc Loc, StringRef Message) = 0; }; -} // end clang namespace -#endif + +} // namespace clang + +#endif // LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H diff --git a/clang/include/clang/Frontend/FrontendPluginRegistry.h b/clang/include/clang/Frontend/FrontendPluginRegistry.h index 9d7ee08..9a85e89 100644 --- a/clang/include/clang/Frontend/FrontendPluginRegistry.h +++ b/clang/include/clang/Frontend/FrontendPluginRegistry.h @@ -1,4 +1,4 @@ -//===-- FrontendAction.h - Pluggable Frontend Action Interface --*- C++ -*-===// +//===- FrontendPluginRegistry.h ---------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -6,6 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// +// +// Pluggable Frontend Action Interface +// +//===----------------------------------------------------------------------===// #ifndef LLVM_CLANG_FRONTEND_FRONTENDPLUGINREGISTRY_H #define LLVM_CLANG_FRONTEND_FRONTENDPLUGINREGISTRY_H @@ -16,8 +20,8 @@ namespace clang { /// The frontend plugin registry. -typedef llvm::Registry FrontendPluginRegistry; +using FrontendPluginRegistry = llvm::Registry; -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_FRONTEND_FRONTENDPLUGINREGISTRY_H diff --git a/clang/include/clang/Frontend/TextDiagnosticBuffer.h b/clang/include/clang/Frontend/TextDiagnosticBuffer.h index 23f168e..2295f9d 100644 --- a/clang/include/clang/Frontend/TextDiagnosticBuffer.h +++ b/clang/include/clang/Frontend/TextDiagnosticBuffer.h @@ -1,4 +1,4 @@ -//===--- TextDiagnosticBuffer.h - Buffer Text Diagnostics -------*- C++ -*-===// +//===- TextDiagnosticBuffer.h - Buffer Text Diagnostics ---------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -15,37 +15,41 @@ #define LLVM_CLANG_FRONTEND_TEXTDIAGNOSTICBUFFER_H #include "clang/Basic/Diagnostic.h" +#include "clang/Basic/SourceLocation.h" +#include +#include +#include #include namespace clang { -class Preprocessor; -class SourceManager; - class TextDiagnosticBuffer : public DiagnosticConsumer { public: - typedef std::vector > DiagList; - typedef DiagList::iterator iterator; - typedef DiagList::const_iterator const_iterator; + using DiagList = std::vector>; + using iterator = DiagList::iterator; + using const_iterator = DiagList::const_iterator; + private: DiagList Errors, Warnings, Remarks, Notes; + /// All - All diagnostics in the order in which they were generated. That /// order likely doesn't correspond to user input order, but it at least /// keeps notes in the right places. Each pair in the vector is a diagnostic /// level and an index into the corresponding DiagList above. std::vector> All; + public: - const_iterator err_begin() const { return Errors.begin(); } - const_iterator err_end() const { return Errors.end(); } + const_iterator err_begin() const { return Errors.begin(); } + const_iterator err_end() const { return Errors.end(); } const_iterator warn_begin() const { return Warnings.begin(); } - const_iterator warn_end() const { return Warnings.end(); } + const_iterator warn_end() const { return Warnings.end(); } const_iterator remark_begin() const { return Remarks.begin(); } - const_iterator remark_end() const { return Remarks.end(); } + const_iterator remark_end() const { return Remarks.end(); } const_iterator note_begin() const { return Notes.begin(); } - const_iterator note_end() const { return Notes.end(); } + const_iterator note_end() const { return Notes.end(); } void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) override; @@ -55,6 +59,6 @@ public: void FlushDiagnostics(DiagnosticsEngine &Diags) const; }; -} // end namspace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_FRONTEND_TEXTDIAGNOSTICBUFFER_H diff --git a/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h b/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h index 8d71fb9..45499b4 100644 --- a/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h +++ b/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h @@ -11,18 +11,24 @@ #define LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICCONSUMER_H #include "clang/Basic/Diagnostic.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/PointerIntPair.h" -#include "llvm/ADT/STLExtras.h" -#include +#include "llvm/ADT/StringRef.h" +#include +#include #include +#include +#include namespace clang { -class DiagnosticsEngine; -class TextDiagnosticBuffer; class FileEntry; +class LangOptions; +class SourceManager; +class TextDiagnosticBuffer; /// VerifyDiagnosticConsumer - Create a diagnostic client which will use /// markers in the input source to check that all the emitted diagnostics match @@ -153,7 +159,7 @@ public: public: /// Constant representing n or more matches. - static const unsigned MaxCount = UINT_MAX; + static const unsigned MaxCount = std::numeric_limits::max(); SourceLocation DirectiveLoc; SourceLocation DiagnosticLoc; @@ -161,7 +167,9 @@ public: unsigned Min, Max; bool MatchAnyLine; - virtual ~Directive() { } + Directive(const Directive &) = delete; + Directive &operator=(const Directive &) = delete; + virtual ~Directive() = default; // Returns true if directive text is valid. // Otherwise returns false and populates E. @@ -173,22 +181,17 @@ public: protected: Directive(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc, bool MatchAnyLine, StringRef Text, unsigned Min, unsigned Max) - : DirectiveLoc(DirectiveLoc), DiagnosticLoc(DiagnosticLoc), - Text(Text), Min(Min), Max(Max), MatchAnyLine(MatchAnyLine) { - assert(!DirectiveLoc.isInvalid() && "DirectiveLoc is invalid!"); - assert((!DiagnosticLoc.isInvalid() || MatchAnyLine) && - "DiagnosticLoc is invalid!"); + : DirectiveLoc(DirectiveLoc), DiagnosticLoc(DiagnosticLoc), + Text(Text), Min(Min), Max(Max), MatchAnyLine(MatchAnyLine) { + assert(!DirectiveLoc.isInvalid() && "DirectiveLoc is invalid!"); + assert((!DiagnosticLoc.isInvalid() || MatchAnyLine) && + "DiagnosticLoc is invalid!"); } - - private: - Directive(const Directive &) = delete; - void operator=(const Directive &) = delete; }; - typedef std::vector> DirectiveList; + using DirectiveList = std::vector>; /// ExpectedData - owns directive objects and deletes on destructor. - /// struct ExpectedData { DirectiveList Errors; DirectiveList Warnings; @@ -215,14 +218,15 @@ private: DiagnosticConsumer *PrimaryClient; std::unique_ptr PrimaryClientOwner; std::unique_ptr Buffer; - const Preprocessor *CurrentPreprocessor; - const LangOptions *LangOpts; - SourceManager *SrcManager; - unsigned ActiveSourceFiles; + const Preprocessor *CurrentPreprocessor = nullptr; + const LangOptions *LangOpts = nullptr; + SourceManager *SrcManager = nullptr; + unsigned ActiveSourceFiles = 0; DirectiveStatus Status; ExpectedData ED; void CheckDiagnostics(); + void setSourceManager(SourceManager &SM) { assert((!SrcManager || SrcManager == &SM) && "SourceManager changed!"); SrcManager = &SM; @@ -231,14 +235,18 @@ private: // These facilities are used for validation in debug builds. class UnparsedFileStatus { llvm::PointerIntPair Data; + public: UnparsedFileStatus(const FileEntry *File, bool FoundDirectives) - : Data(File, FoundDirectives) {} + : Data(File, FoundDirectives) {} + const FileEntry *getFile() const { return Data.getPointer(); } bool foundDirectives() const { return Data.getInt(); } }; - typedef llvm::DenseMap ParsedFilesMap; - typedef llvm::DenseMap UnparsedFilesMap; + + using ParsedFilesMap = llvm::DenseMap; + using UnparsedFilesMap = llvm::DenseMap; + ParsedFilesMap ParsedFiles; UnparsedFilesMap UnparsedFiles; @@ -274,6 +282,6 @@ public: const Diagnostic &Info) override; }; -} // end namspace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICCONSUMER_H diff --git a/clang/lib/Frontend/ASTUnit.cpp b/clang/lib/Frontend/ASTUnit.cpp index d73bc28..cd3664b 100644 --- a/clang/lib/Frontend/ASTUnit.cpp +++ b/clang/lib/Frontend/ASTUnit.cpp @@ -1,4 +1,4 @@ -//===--- ASTUnit.cpp - ASTUnit utility --------------------------*- C++ -*-===// +//===- ASTUnit.cpp - ASTUnit utility --------------------------------------===// // // The LLVM Compiler Infrastructure // @@ -14,45 +14,99 @@ #include "clang/Frontend/ASTUnit.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" -#include "clang/AST/DeclVisitor.h" -#include "clang/AST/StmtVisitor.h" +#include "clang/AST/CommentCommandTraits.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclBase.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclGroup.h" +#include "clang/AST/DeclObjC.h" +#include "clang/AST/DeclTemplate.h" +#include "clang/AST/DeclarationName.h" +#include "clang/AST/ExternalASTSource.h" +#include "clang/AST/PrettyPrinter.h" +#include "clang/AST/Type.h" #include "clang/AST/TypeOrdering.h" #include "clang/Basic/Diagnostic.h" +#include "clang/Basic/FileManager.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/LangOptions.h" #include "clang/Basic/MemoryBufferCache.h" +#include "clang/Basic/Module.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/VirtualFileSystem.h" #include "clang/Frontend/CompilerInstance.h" +#include "clang/Frontend/CompilerInvocation.h" +#include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/FrontendOptions.h" #include "clang/Frontend/MultiplexConsumer.h" +#include "clang/Frontend/PCHContainerOperations.h" +#include "clang/Frontend/PrecompiledPreamble.h" #include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" +#include "clang/Lex/HeaderSearchOptions.h" +#include "clang/Lex/Lexer.h" +#include "clang/Lex/PPCallbacks.h" +#include "clang/Lex/PreprocessingRecord.h" #include "clang/Lex/Preprocessor.h" #include "clang/Lex/PreprocessorOptions.h" +#include "clang/Lex/Token.h" +#include "clang/Sema/CodeCompleteConsumer.h" +#include "clang/Sema/CodeCompleteOptions.h" #include "clang/Sema/Sema.h" +#include "clang/Serialization/ASTBitCodes.h" #include "clang/Serialization/ASTReader.h" #include "clang/Serialization/ASTWriter.h" +#include "clang/Serialization/ContinuousRangeMap.h" +#include "clang/Serialization/Module.h" #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/IntrusiveRefCntPtr.h" +#include "llvm/ADT/None.h" +#include "llvm/ADT/Optional.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSet.h" +#include "llvm/ADT/Twine.h" +#include "llvm/ADT/iterator_range.h" +#include "llvm/Bitcode/BitstreamWriter.h" +#include "llvm/Support/Allocator.h" +#include "llvm/Support/Casting.h" #include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/DJB.h" -#include "llvm/Support/Host.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/ErrorOr.h" +#include "llvm/Support/FileSystem.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Mutex.h" -#include "llvm/Support/MutexGuard.h" #include "llvm/Support/Timer.h" #include "llvm/Support/raw_ostream.h" +#include #include +#include +#include #include #include +#include +#include +#include +#include +#include using namespace clang; using llvm::TimeRecord; namespace { + class SimpleTimer { bool WantTiming; TimeRecord Start; @@ -64,11 +118,6 @@ namespace { Start = TimeRecord::getCurrentTime(); } - void setOutput(const Twine &Output) { - if (WantTiming) - this->Output = Output.str(); - } - ~SimpleTimer() { if (WantTiming) { TimeRecord Elapsed = TimeRecord::getCurrentTime(); @@ -78,22 +127,29 @@ namespace { llvm::errs() << '\n'; } } + + void setOutput(const Twine &Output) { + if (WantTiming) + this->Output = Output.str(); + } }; - template - std::unique_ptr valueOrNull(llvm::ErrorOr> Val) { - if (!Val) - return nullptr; - return std::move(*Val); - } +} // namespace - template - bool moveOnNoError(llvm::ErrorOr Val, T &Output) { - if (!Val) - return false; - Output = std::move(*Val); - return true; - } +template +static std::unique_ptr valueOrNull(llvm::ErrorOr> Val) { + if (!Val) + return nullptr; + return std::move(*Val); +} + +template +static bool moveOnNoError(llvm::ErrorOr Val, T &Output) { + if (!Val) + return false; + Output = std::move(*Val); + return true; +} /// \brief Get a source buffer for \p MainFilePath, handling all file-to-file /// and file-to-buffer remappings inside \p Invocation. @@ -156,7 +212,6 @@ getBufferForFileHandlingRemapping(const CompilerInvocation &Invocation, return nullptr; return llvm::MemoryBuffer::getMemBufferCopy(Buffer->getBuffer(), FilePath); } -} struct ASTUnit::ASTWriterData { SmallString<128> Buffer; @@ -183,20 +238,10 @@ const unsigned DefaultPreambleRebuildInterval = 5; static std::atomic ActiveASTUnitObjects; ASTUnit::ASTUnit(bool _MainFileIsAST) - : Reader(nullptr), HadModuleLoaderFatalFailure(false), - OnlyLocalDecls(false), CaptureDiagnostics(false), - MainFileIsAST(_MainFileIsAST), - TUKind(TU_Complete), WantTiming(getenv("LIBCLANG_TIMING")), - OwnsRemappedFileBuffers(true), - NumStoredDiagnosticsFromDriver(0), - PreambleRebuildCounter(0), - NumWarningsInPreamble(0), - ShouldCacheCodeCompletionResults(false), - IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), - CompletionCacheTopLevelHashValue(0), - PreambleTopLevelHashValue(0), - CurrentTopLevelHashValue(0), - UnsafeToFree(false) { + : MainFileIsAST(_MainFileIsAST), WantTiming(getenv("LIBCLANG_TIMING")), + ShouldCacheCodeCompletionResults(false), + IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), + UnsafeToFree(false) { if (getenv("LIBCLANG_OBJTRACKING")) fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects); } @@ -278,7 +323,7 @@ static unsigned getDeclShowContexts(const NamedDecl *ND, // Part of the nested-name-specifier in C++0x. if (LangOpts.CPlusPlus11) IsNestedNameSpecifier = true; - } else if (const RecordDecl *Record = dyn_cast(ND)) { + } else if (const auto *Record = dyn_cast(ND)) { if (Record->isUnion()) Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag); else @@ -319,7 +364,7 @@ void ASTUnit::CacheCodeCompletionResults() { ClearCachedCompletionResults(); // Gather the set of global code completions. - typedef CodeCompletionResult Result; + using Result = CodeCompletionResult; SmallVector Results; CachedCompletionAllocator = std::make_shared(); CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator); @@ -330,7 +375,7 @@ void ASTUnit::CacheCodeCompletionResults() { llvm::DenseMap CompletionTypes; CodeCompletionContext CCContext(CodeCompletionContext::CCC_TopLevel); - for (Result &R : Results) { + for (auto &R : Results) { switch (R.Kind) { case Result::RK_Declaration: { bool IsNestedNameSpecifier = false; @@ -470,8 +515,8 @@ class ASTInfoCollector : public ASTReaderListener { std::shared_ptr &TargetOpts; IntrusiveRefCntPtr &Target; unsigned &Counter; + bool InitializedLanguage = false; - bool InitializedLanguage; public: ASTInfoCollector(Preprocessor &PP, ASTContext *Context, HeaderSearchOptions &HSOpts, PreprocessorOptions &PPOpts, @@ -480,7 +525,7 @@ public: IntrusiveRefCntPtr &Target, unsigned &Counter) : PP(PP), Context(Context), HSOpts(HSOpts), PPOpts(PPOpts), LangOpt(LangOpt), TargetOpts(TargetOpts), Target(Target), - Counter(Counter), InitializedLanguage(false) {} + Counter(Counter) {} bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override { @@ -494,16 +539,15 @@ public: return false; } - virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, - StringRef SpecificModuleCachePath, - bool Complain) override { + bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, + StringRef SpecificModuleCachePath, + bool Complain) override { this->HSOpts = HSOpts; return false; } - virtual bool - ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, - std::string &SuggestedPredefines) override { + bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, + std::string &SuggestedPredefines) override { this->PPOpts = PPOpts; return false; } @@ -557,19 +601,18 @@ private: } }; - /// \brief Diagnostic consumer that saves each diagnostic it is given. +/// \brief Diagnostic consumer that saves each diagnostic it is given. class StoredDiagnosticConsumer : public DiagnosticConsumer { SmallVectorImpl *StoredDiags; SmallVectorImpl *StandaloneDiags; - const LangOptions *LangOpts; - SourceManager *SourceMgr; + const LangOptions *LangOpts = nullptr; + SourceManager *SourceMgr = nullptr; public: StoredDiagnosticConsumer( SmallVectorImpl *StoredDiags, SmallVectorImpl *StandaloneDiags) - : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags), - LangOpts(nullptr), SourceMgr(nullptr) { + : StoredDiags(StoredDiags), StandaloneDiags(StandaloneDiags) { assert((StoredDiags || StandaloneDiags) && "No output collections were passed to StoredDiagnosticConsumer."); } @@ -590,15 +633,15 @@ public: class CaptureDroppedDiagnostics { DiagnosticsEngine &Diags; StoredDiagnosticConsumer Client; - DiagnosticConsumer *PreviousClient; + DiagnosticConsumer *PreviousClient = nullptr; std::unique_ptr OwningPreviousClient; public: - CaptureDroppedDiagnostics(bool RequestCapture, DiagnosticsEngine &Diags, - SmallVectorImpl *StoredDiags, - SmallVectorImpl *StandaloneDiags) - : Diags(Diags), Client(StoredDiags, StandaloneDiags), PreviousClient(nullptr) - { + CaptureDroppedDiagnostics( + bool RequestCapture, DiagnosticsEngine &Diags, + SmallVectorImpl *StoredDiags, + SmallVectorImpl *StandaloneDiags) + : Diags(Diags), Client(StoredDiags, StandaloneDiags) { if (RequestCapture || Diags.getClient() == nullptr) { OwningPreviousClient = Diags.takeClient(); PreviousClient = Diags.getClient(); @@ -612,7 +655,7 @@ public: } }; -} // anonymous namespace +} // namespace static ASTUnit::StandaloneDiagnostic makeStandaloneDiagnostic(const LangOptions &LangOpts, @@ -634,7 +677,7 @@ void StoredDiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level Level, } if (StandaloneDiags) { - llvm::Optional StoredDiag = llvm::None; + llvm::Optional StoredDiag = None; if (!ResultDiag) { StoredDiag.emplace(Level, Info); ResultDiag = StoredDiag.getPointer(); @@ -693,7 +736,7 @@ std::unique_ptr ASTUnit::LoadFromASTFile( llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > + llvm::CrashRecoveryContextReleaseRefCleanup> DiagCleanup(Diags.get()); ConfigureDiags(Diags, *AST, CaptureDiagnostics); @@ -741,7 +784,7 @@ std::unique_ptr ASTUnit::LoadFromASTFile( bool disableValid = false; if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION")) disableValid = true; - AST->Reader = new ASTReader(PP, AST->Ctx.get(), PCHContainerRdr, { }, + AST->Reader = new ASTReader(PP, AST->Ctx.get(), PCHContainerRdr, {}, /*isysroot=*/"", /*DisableValidation=*/disableValid, AllowPCHWithCompilerErrors); @@ -794,20 +837,20 @@ std::unique_ptr ASTUnit::LoadFromASTFile( return AST; } -namespace { - /// \brief Add the given macro to the hash of all top-level entities. -void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) { +static void AddDefinedMacroToHash(const Token &MacroNameTok, unsigned &Hash) { Hash = llvm::djbHash(MacroNameTok.getIdentifierInfo()->getName(), Hash); } +namespace { + /// \brief Preprocessor callback class that updates a hash value with the names /// of all macros that have been defined by the translation unit. class MacroDefinitionTrackerPPCallbacks : public PPCallbacks { unsigned &Hash; public: - explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { } + explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) {} void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override { @@ -815,8 +858,10 @@ public: } }; +} // namespace + /// \brief Add the given declaration to the hash of all top-level entities. -void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { +static void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { if (!D) return; @@ -827,8 +872,8 @@ void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit())) return; - if (NamedDecl *ND = dyn_cast(D)) { - if (EnumDecl *EnumD = dyn_cast(D)) { + if (const auto *ND = dyn_cast(D)) { + if (const auto *EnumD = dyn_cast(D)) { // For an unscoped enum include the enumerators in the hash since they // enter the top-level namespace. if (!EnumD->isScoped()) { @@ -848,8 +893,8 @@ void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { return; } - if (ImportDecl *ImportD = dyn_cast(D)) { - if (Module *Mod = ImportD->getImportedModule()) { + if (const auto *ImportD = dyn_cast(D)) { + if (const Module *Mod = ImportD->getImportedModule()) { std::string ModName = Mod->getFullModuleName(); Hash = llvm::djbHash(ModName, Hash); } @@ -857,13 +902,15 @@ void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { } } +namespace { + class TopLevelDeclTrackerConsumer : public ASTConsumer { ASTUnit &Unit; unsigned &Hash; public: TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash) - : Unit(_Unit), Hash(Hash) { + : Unit(_Unit), Hash(Hash) { Hash = 0; } @@ -886,14 +933,14 @@ public: void handleFileLevelDecl(Decl *D) { Unit.addFileLevelDecl(D); - if (NamespaceDecl *NSD = dyn_cast(D)) { + if (auto *NSD = dyn_cast(D)) { for (auto *I : NSD->decls()) handleFileLevelDecl(I); } } bool HandleTopLevelDecl(DeclGroupRef D) override { - for (Decl *TopLevelDecl : D) + for (auto *TopLevelDecl : D) handleTopLevelDecl(TopLevelDecl); return true; } @@ -902,7 +949,7 @@ public: void HandleInterestingDecl(DeclGroupRef) override {} void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { - for (Decl *TopLevelDecl : D) + for (auto *TopLevelDecl : D) handleTopLevelDecl(TopLevelDecl); } @@ -932,6 +979,7 @@ public: TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} bool hasCodeCompletionSupport() const override { return false; } + TranslationUnitKind getTranslationUnitKind() override { return Unit.getTranslationUnitKind(); } @@ -949,7 +997,7 @@ public: void AfterPCHEmitted(ASTWriter &Writer) override { TopLevelDeclIDs.reserve(TopLevelDecls.size()); - for (Decl *D : TopLevelDecls) { + for (const auto *D : TopLevelDecls) { // Invalid top-level decls may not have been serialized. if (D->isInvalidDecl()) continue; @@ -958,7 +1006,7 @@ public: } void HandleTopLevelDecl(DeclGroupRef DG) override { - for (Decl *D : DG) { + for (auto *D : DG) { // FIXME: Currently ObjC method declarations are incorrectly being // reported as top-level declarations, even though their DeclContext // is the containing ObjC @interface/@implementation. This is a @@ -981,7 +1029,7 @@ private: llvm::SmallVector PreambleDiags; }; -} // anonymous namespace +} // namespace static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) { return StoredDiag.getLocation().isValid(); @@ -1004,7 +1052,7 @@ static void checkAndSanitizeDiags(SmallVectorImpl & // been careful to make sure that the source manager's state // before and after are identical, so that we can reuse the source // location itself. - for (StoredDiagnostic &SD : StoredDiagnostics) { + for (auto &SD : StoredDiagnostics) { if (SD.getLocation().isValid()) { FullSourceLoc Loc(SD.getLocation(), SM); SD.setLocation(Loc); @@ -1192,9 +1240,9 @@ makeStandaloneDiagnostic(const LangOptions &LangOpts, if (OutDiag.Filename.empty()) return OutDiag; OutDiag.LocOffset = SM.getFileOffset(FileLoc); - for (const CharSourceRange &Range : InDiag.getRanges()) + for (const auto &Range : InDiag.getRanges()) OutDiag.Ranges.push_back(makeStandaloneRange(Range, SM, LangOpts)); - for (const FixItHint &FixIt : InDiag.getFixIts()) + for (const auto &FixIt : InDiag.getFixIts()) OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, FixIt)); return OutDiag; @@ -1226,7 +1274,6 @@ ASTUnit::getMainBufferWithPrecompiledPreamble( const CompilerInvocation &PreambleInvocationIn, IntrusiveRefCntPtr VFS, bool AllowRebuild, unsigned MaxLines) { - auto MainFilePath = PreambleInvocationIn.getFrontendOpts().Inputs[0].getFile(); std::unique_ptr MainFileBuffer = @@ -1345,7 +1392,7 @@ void ASTUnit::RealizeTopLevelDeclsFromPreamble() { std::vector Resolved; Resolved.reserve(TopLevelDeclsInPreamble.size()); ExternalASTSource &Source = *getASTContext().getExternalSource(); - for (serialization::DeclID TopLevelDecl : TopLevelDeclsInPreamble) { + for (const auto TopLevelDecl : TopLevelDeclsInPreamble) { // Resolve the declaration ID to an actual declaration, possibly // deserializing the declaration in the process. if (Decl *D = Source.GetExternalDecl(TopLevelDecl)) @@ -1389,12 +1436,12 @@ StringRef ASTUnit::getMainFileName() const { return FE->getName(); } - return StringRef(); + return {}; } StringRef ASTUnit::getASTFileName() const { if (!isMainFileAST()) - return StringRef(); + return {}; serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); @@ -1461,7 +1508,7 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(OwnAST.get()); llvm::CrashRecoveryContextCleanupRegistrar > + llvm::CrashRecoveryContextReleaseRefCleanup> DiagCleanup(Diags.get()); // We'll manage file buffers ourselves. @@ -1629,7 +1676,7 @@ std::unique_ptr ASTUnit::LoadFromCompilerInvocation( llvm::CrashRecoveryContextCleanupRegistrar ASTUnitCleanup(AST.get()); llvm::CrashRecoveryContextCleanupRegistrar > + llvm::CrashRecoveryContextReleaseRefCleanup> DiagCleanup(Diags.get()); if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), @@ -1658,11 +1705,10 @@ ASTUnit *ASTUnit::LoadFromCommandLine( std::shared_ptr CI; { - CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, &StoredDiagnostics, nullptr); - CI = clang::createInvocationFromCommandLine( + CI = createInvocationFromCommandLine( llvm::makeArrayRef(ArgBegin, ArgEnd), Diags, VFS); if (!CI) return nullptr; @@ -1768,7 +1814,6 @@ bool ASTUnit::Reparse(std::shared_ptr PCHContainerOps, OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation, VFS); - // Clear out the diagnostics state. FileMgr.reset(); getDiagnostics().Reset(); @@ -1811,6 +1856,7 @@ void ASTUnit::ResetForParse() { //----------------------------------------------------------------------------// namespace { + /// \brief Code completion consumer that combines the cached code-completion /// results from an ASTUnit with the code-completion results provided to it, /// then passes the result on to @@ -1822,9 +1868,8 @@ namespace { public: AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, const CodeCompleteOptions &CodeCompleteOpts) - : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), - AST(AST), Next(Next) - { + : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), + AST(AST), Next(Next) { // Compute the set of contexts in which we will look when we don't have // any information about the specific context. NormalContexts @@ -1866,7 +1911,8 @@ namespace { return Next.getCodeCompletionTUInfo(); } }; -} // anonymous namespace + +} // namespace /// \brief Helper function that computes which global names are hidden by the /// local code-completion results. @@ -1921,7 +1967,7 @@ static void CalculateHiddenNames(const CodeCompletionContext &Context, return; } - typedef CodeCompletionResult Result; + using Result = CodeCompletionResult; for (unsigned I = 0; I != NumResults; ++I) { if (Results[I].Kind != Result::RK_Declaration) continue; @@ -1963,7 +2009,7 @@ void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, ? NormalContexts : (1LL << Context.getKind()); // Contains the set of names that are hidden by "local" completion results. llvm::StringSet HiddenNames; - typedef CodeCompletionResult Result; + using Result = CodeCompletionResult; SmallVector AllResults; for (ASTUnit::cached_completion_iterator C = AST.cached_completion_begin(), @@ -2259,7 +2305,7 @@ bool ASTUnit::serialize(raw_ostream &OS) { return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS); } -typedef ContinuousRangeMap SLocRemap; +using SLocRemap = ContinuousRangeMap; void ASTUnit::TranslateStoredDiagnostics( FileManager &FileMgr, @@ -2273,7 +2319,7 @@ void ASTUnit::TranslateStoredDiagnostics( SmallVector Result; Result.reserve(Diags.size()); - for (const StandaloneDiagnostic &SD : Diags) { + for (const auto &SD : Diags) { // Rebuild the StoredDiagnostic. if (SD.Filename.empty()) continue; @@ -2305,7 +2351,7 @@ void ASTUnit::TranslateStoredDiagnostics( SmallVector FixIts; FixIts.reserve(SD.FixIts.size()); - for (const StandaloneFixIt &FixIt : SD.FixIts) { + for (const auto &FixIt : SD.FixIts) { FixIts.push_back(FixItHint()); FixItHint &FH = FixIts.back(); FH.CodeToInsert = FixIt.CodeToInsert; @@ -2488,7 +2534,7 @@ SourceLocation ASTUnit::getEndOfPreambleFileID() const { FID = SourceMgr->getPreambleFileID(); if (FID.isInvalid()) - return SourceLocation(); + return {}; return SourceMgr->getLocForEndOfFile(FID); } @@ -2499,7 +2545,7 @@ SourceLocation ASTUnit::getStartOfMainFileID() const { FID = SourceMgr->getMainFileID(); if (FID.isInvalid()) - return SourceLocation(); + return {}; return SourceMgr->getLocForStartOfFile(FID); } @@ -2523,7 +2569,7 @@ bool ASTUnit::visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn) { if (isMainFileAST()) { serialization::ModuleFile & Mod = Reader->getModuleManager().getPrimaryModule(); - for (const Decl *D : Reader->getModuleFileLevelDecls(Mod)) { + for (const auto *D : Reader->getModuleFileLevelDecls(Mod)) { if (!Fn(context, D)) return false; } diff --git a/clang/lib/Frontend/DiagnosticRenderer.cpp b/clang/lib/Frontend/DiagnosticRenderer.cpp index e326384..df426af 100644 --- a/clang/lib/Frontend/DiagnosticRenderer.cpp +++ b/clang/lib/Frontend/DiagnosticRenderer.cpp @@ -1,4 +1,4 @@ -//===--- DiagnosticRenderer.cpp - Diagnostic Pretty-Printing --------------===// +//===- DiagnosticRenderer.cpp - Diagnostic Pretty-Printing ----------------===// // // The LLVM Compiler Infrastructure // @@ -8,24 +8,34 @@ //===----------------------------------------------------------------------===// #include "clang/Frontend/DiagnosticRenderer.h" +#include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticOptions.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Edit/Commit.h" #include "clang/Edit/EditedSource.h" #include "clang/Edit/EditsReceiver.h" #include "clang/Lex/Lexer.h" -#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/None.h" #include "llvm/ADT/SmallString.h" -#include "llvm/Support/ErrorHandling.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" #include "llvm/Support/raw_ostream.h" #include +#include +#include +#include + using namespace clang; DiagnosticRenderer::DiagnosticRenderer(const LangOptions &LangOpts, DiagnosticOptions *DiagOpts) - : LangOpts(LangOpts), DiagOpts(DiagOpts), LastLevel() {} + : LangOpts(LangOpts), DiagOpts(DiagOpts), LastLevel() {} -DiagnosticRenderer::~DiagnosticRenderer() {} +DiagnosticRenderer::~DiagnosticRenderer() = default; namespace { @@ -34,24 +44,24 @@ class FixitReceiver : public edit::EditsReceiver { public: FixitReceiver(SmallVectorImpl &MergedFixits) - : MergedFixits(MergedFixits) { } + : MergedFixits(MergedFixits) {} + void insert(SourceLocation loc, StringRef text) override { MergedFixits.push_back(FixItHint::CreateInsertion(loc, text)); } + void replace(CharSourceRange range, StringRef text) override { MergedFixits.push_back(FixItHint::CreateReplacement(range, text)); } }; -} +} // namespace static void mergeFixits(ArrayRef FixItHints, const SourceManager &SM, const LangOptions &LangOpts, SmallVectorImpl &MergedFixits) { edit::Commit commit(SM, LangOpts); - for (ArrayRef::const_iterator - I = FixItHints.begin(), E = FixItHints.end(); I != E; ++I) { - const FixItHint &Hint = *I; + for (const auto &Hint : FixItHints) if (Hint.CodeToInsert.empty()) { if (Hint.InsertFromRange.isValid()) commit.insertFromRange(Hint.RemoveRange.getBegin(), @@ -67,7 +77,6 @@ static void mergeFixits(ArrayRef FixItHints, commit.insert(Hint.RemoveRange.getBegin(), Hint.CodeToInsert, /*afterToken=*/false, Hint.BeforePreviousInsertions); } - } edit::EditedSource Editor(SM, LangOpts); if (Editor.commit(commit)) { @@ -100,11 +109,9 @@ void DiagnosticRenderer::emitDiagnostic(FullSourceLoc Loc, FixItHints = MergedFixits; } - for (ArrayRef::const_iterator I = FixItHints.begin(), - E = FixItHints.end(); - I != E; ++I) - if (I->RemoveRange.isValid()) - MutableRanges.push_back(I->RemoveRange); + for (const auto &Hint : FixItHints) + if (Hint.RemoveRange.isValid()) + MutableRanges.push_back(Hint.RemoveRange); FullSourceLoc UnexpandedLoc = Loc; @@ -134,7 +141,6 @@ void DiagnosticRenderer::emitDiagnostic(FullSourceLoc Loc, endDiagnostic(D, Level); } - void DiagnosticRenderer::emitStoredDiagnostic(StoredDiagnostic &Diag) { emitDiagnostic(Diag.getLocation(), Diag.getLevel(), Diag.getMessage(), Diag.getRanges(), Diag.getFixIts(), @@ -243,10 +249,10 @@ void DiagnosticRenderer::emitImportStackRecursively(FullSourceLoc Loc, /// on demand. void DiagnosticRenderer::emitModuleBuildStack(const SourceManager &SM) { ModuleBuildStack Stack = SM.getModuleBuildStack(); - for (unsigned I = 0, N = Stack.size(); I != N; ++I) { - emitBuildingModuleLocation(Stack[I].second, Stack[I].second.getPresumedLoc( - DiagOpts->ShowPresumedLoc), - Stack[I].first); + for (const auto &I : Stack) { + emitBuildingModuleLocation(I.second, I.second.getPresumedLoc( + DiagOpts->ShowPresumedLoc), + I.first); } } @@ -261,7 +267,7 @@ retrieveMacroLocation(SourceLocation Loc, FileID MacroFileID, if (MacroFileID == CaretFileID) return Loc; if (!Loc.isMacroID()) - return SourceLocation(); + return {}; SourceLocation MacroLocation, MacroArgLocation; @@ -342,11 +348,12 @@ mapDiagnosticRanges(FullSourceLoc CaretLoc, ArrayRef Ranges, const SourceManager *SM = &CaretLoc.getManager(); - for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { - if (I->isInvalid()) continue; + for (const auto &Range : Ranges) { + if (Range.isInvalid()) + continue; - SourceLocation Begin = I->getBegin(), End = I->getEnd(); - bool IsTokenRange = I->isTokenRange(); + SourceLocation Begin = Range.getBegin(), End = Range.getEnd(); + bool IsTokenRange = Range.isTokenRange(); FileID BeginFileID = SM->getFileID(Begin); FileID EndFileID = SM->getFileID(End); @@ -466,8 +473,9 @@ static bool checkRangesForMacroArgExpansion(FullSourceLoc Loc, /// Count all valid ranges. unsigned ValidCount = 0; - for (auto I : Ranges) - if (I.isValid()) ValidCount++; + for (const auto &Range : Ranges) + if (Range.isValid()) + ValidCount++; if (ValidCount > SpellingRanges.size()) return false; @@ -480,10 +488,9 @@ static bool checkRangesForMacroArgExpansion(FullSourceLoc Loc, if (!Loc.isMacroArgExpansion(&ArgumentLoc)) return false; - for (auto I = SpellingRanges.begin(), E = SpellingRanges.end(); I != E; ++I) { - if (!checkRangeForMacroArgExpansion(*I, Loc.getManager(), ArgumentLoc)) + for (const auto &Range : SpellingRanges) + if (!checkRangeForMacroArgExpansion(Range, Loc.getManager(), ArgumentLoc)) return false; - } return true; } @@ -562,7 +569,7 @@ void DiagnosticRenderer::emitMacroExpansions(FullSourceLoc Loc, emitSingleMacroExpansion(*I, Level, Ranges); } -DiagnosticNoteRenderer::~DiagnosticNoteRenderer() {} +DiagnosticNoteRenderer::~DiagnosticNoteRenderer() = default; void DiagnosticNoteRenderer::emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) { diff --git a/clang/lib/Frontend/TextDiagnosticBuffer.cpp b/clang/lib/Frontend/TextDiagnosticBuffer.cpp index 2885073..44bb2bc 100644 --- a/clang/lib/Frontend/TextDiagnosticBuffer.cpp +++ b/clang/lib/Frontend/TextDiagnosticBuffer.cpp @@ -1,4 +1,4 @@ -//===--- TextDiagnosticBuffer.cpp - Buffer Text Diagnostics ---------------===// +//===- TextDiagnosticBuffer.cpp - Buffer Text Diagnostics -----------------===// // // The LLVM Compiler Infrastructure // @@ -12,13 +12,15 @@ //===----------------------------------------------------------------------===// #include "clang/Frontend/TextDiagnosticBuffer.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/LLVM.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/ErrorHandling.h" + using namespace clang; /// HandleDiagnostic - Store the errors, warnings, and notes that are /// reported. -/// void TextDiagnosticBuffer::HandleDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info) { // Default implementation (Warnings/errors count). @@ -50,25 +52,24 @@ void TextDiagnosticBuffer::HandleDiagnostic(DiagnosticsEngine::Level Level, } void TextDiagnosticBuffer::FlushDiagnostics(DiagnosticsEngine &Diags) const { - for (auto it = All.begin(), ie = All.end(); it != ie; ++it) { - auto Diag = Diags.Report(Diags.getCustomDiagID(it->first, "%0")); - switch (it->first) { + for (const auto &I : All) { + auto Diag = Diags.Report(Diags.getCustomDiagID(I.first, "%0")); + switch (I.first) { default: llvm_unreachable( "Diagnostic not handled during diagnostic flushing!"); case DiagnosticsEngine::Note: - Diag << Notes[it->second].second; + Diag << Notes[I.second].second; break; case DiagnosticsEngine::Warning: - Diag << Warnings[it->second].second; + Diag << Warnings[I.second].second; break; case DiagnosticsEngine::Remark: - Diag << Remarks[it->second].second; + Diag << Remarks[I.second].second; break; case DiagnosticsEngine::Error: case DiagnosticsEngine::Fatal: - Diag << Errors[it->second].second; + Diag << Errors[I.second].second; break; } } } - diff --git a/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp b/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp index 0df5393..129a233 100644 --- a/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp +++ b/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp @@ -1,4 +1,4 @@ -//===---- VerifyDiagnosticConsumer.cpp - Verifying Diagnostic Client ------===// +//===- VerifyDiagnosticConsumer.cpp - Verifying Diagnostic Client ---------===// // // The LLVM Compiler Infrastructure // @@ -13,27 +13,48 @@ #include "clang/Frontend/VerifyDiagnosticConsumer.h" #include "clang/Basic/CharInfo.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/FileManager.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/SourceManager.h" +#include "clang/Basic/TokenKinds.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/TextDiagnosticBuffer.h" #include "clang/Lex/HeaderSearch.h" +#include "clang/Lex/Lexer.h" +#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/Preprocessor.h" +#include "clang/Lex/Token.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/Twine.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Regex.h" #include "llvm/Support/raw_ostream.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include using namespace clang; -typedef VerifyDiagnosticConsumer::Directive Directive; -typedef VerifyDiagnosticConsumer::DirectiveList DirectiveList; -typedef VerifyDiagnosticConsumer::ExpectedData ExpectedData; + +using Directive = VerifyDiagnosticConsumer::Directive; +using DirectiveList = VerifyDiagnosticConsumer::DirectiveList; +using ExpectedData = VerifyDiagnosticConsumer::ExpectedData; VerifyDiagnosticConsumer::VerifyDiagnosticConsumer(DiagnosticsEngine &Diags_) - : Diags(Diags_), - PrimaryClient(Diags.getClient()), PrimaryClientOwner(Diags.takeClient()), - Buffer(new TextDiagnosticBuffer()), CurrentPreprocessor(nullptr), - LangOpts(nullptr), SrcManager(nullptr), ActiveSourceFiles(0), - Status(HasNoDirectives) -{ + : Diags(Diags_), PrimaryClient(Diags.getClient()), + PrimaryClientOwner(Diags.takeClient()), + Buffer(new TextDiagnosticBuffer()), Status(HasNoDirectives) { if (Diags.hasSourceManager()) setSourceManager(Diags.getSourceManager()); } @@ -48,14 +69,16 @@ VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() { } #ifndef NDEBUG + namespace { + class VerifyFileTracker : public PPCallbacks { VerifyDiagnosticConsumer &Verify; SourceManager &SM; public: VerifyFileTracker(VerifyDiagnosticConsumer &Verify, SourceManager &SM) - : Verify(Verify), SM(SM) { } + : Verify(Verify), SM(SM) {} /// \brief Hook into the preprocessor and update the list of parsed /// files when the preprocessor indicates a new file is entered. @@ -66,7 +89,9 @@ public: VerifyDiagnosticConsumer::IsParsed); } }; -} // End anonymous namespace. + +} // namespace + #endif // DiagnosticConsumer interface. @@ -79,10 +104,10 @@ void VerifyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts, CurrentPreprocessor = PP; this->LangOpts = &LangOpts; setSourceManager(PP->getSourceManager()); - const_cast(PP)->addCommentHandler(this); + const_cast(PP)->addCommentHandler(this); #ifndef NDEBUG // Debug build tracks parsed files. - const_cast(PP)->addPPCallbacks( + const_cast(PP)->addPPCallbacks( llvm::make_unique(*this, *SrcManager)); #endif } @@ -99,7 +124,8 @@ void VerifyDiagnosticConsumer::EndSourceFile() { // Detach comment handler once last active source file completed. if (--ActiveSourceFiles == 0) { if (CurrentPreprocessor) - const_cast(CurrentPreprocessor)->removeCommentHandler(this); + const_cast(CurrentPreprocessor)-> + removeCommentHandler(this); // Check diagnostics once last file completed. CheckDiagnostics(); @@ -152,19 +178,18 @@ void VerifyDiagnosticConsumer::HandleDiagnostic( // Checking diagnostics implementation. //===----------------------------------------------------------------------===// -typedef TextDiagnosticBuffer::DiagList DiagList; -typedef TextDiagnosticBuffer::const_iterator const_diag_iterator; +using DiagList = TextDiagnosticBuffer::DiagList; +using const_diag_iterator = TextDiagnosticBuffer::const_iterator; namespace { /// StandardDirective - Directive with string matching. -/// class StandardDirective : public Directive { public: StandardDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc, bool MatchAnyLine, StringRef Text, unsigned Min, unsigned Max) - : Directive(DirectiveLoc, DiagnosticLoc, MatchAnyLine, Text, Min, Max) { } + : Directive(DirectiveLoc, DiagnosticLoc, MatchAnyLine, Text, Min, Max) {} bool isValid(std::string &Error) override { // all strings are considered valid; even empty ones @@ -177,14 +202,13 @@ public: }; /// RegexDirective - Directive with regular-expression matching. -/// class RegexDirective : public Directive { public: RegexDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc, bool MatchAnyLine, StringRef Text, unsigned Min, unsigned Max, StringRef RegexStr) - : Directive(DirectiveLoc, DiagnosticLoc, MatchAnyLine, Text, Min, Max), - Regex(RegexStr) { } + : Directive(DirectiveLoc, DiagnosticLoc, MatchAnyLine, Text, Min, Max), + Regex(RegexStr) {} bool isValid(std::string &Error) override { return Regex.isValid(Error); @@ -202,7 +226,7 @@ class ParseHelper { public: ParseHelper(StringRef S) - : Begin(S.begin()), End(S.end()), C(Begin), P(Begin), PEnd(nullptr) {} + : Begin(S.begin()), End(S.end()), C(Begin), P(Begin) {} // Return true if string literal is next. bool Next(StringRef S) { @@ -210,7 +234,7 @@ public: PEnd = C + S.size(); if (PEnd > End) return false; - return !memcmp(P, S.data(), S.size()); + return memcmp(P, S.data(), S.size()) == 0; } // Return true if number is next. @@ -321,16 +345,23 @@ public: return !(C < End); } - const char * const Begin; // beginning of expected content - const char * const End; // end of expected content (1-past) - const char *C; // position of next char in content + // Beginning of expected content. + const char * const Begin; + + // End of expected content (1-past). + const char * const End; + + // Position of next char in content. + const char *C; + const char *P; private: - const char *PEnd; // previous next/search subject end (1-past) + // Previous next/search subject end (1-past). + const char *PEnd = nullptr; }; -} // namespace anonymous +} // anonymous /// ParseDirective - Go through the comment and see if it indicates expected /// diagnostics. If so, then put them in the appropriate directive list. @@ -701,21 +732,20 @@ static unsigned PrintExpected(DiagnosticsEngine &Diags, SmallString<256> Fmt; llvm::raw_svector_ostream OS(Fmt); - for (auto *DirPtr : DL) { - Directive &D = *DirPtr; - if (D.DiagnosticLoc.isInvalid()) + for (const auto *D : DL) { + if (D->DiagnosticLoc.isInvalid()) OS << "\n File *"; else - OS << "\n File " << SourceMgr.getFilename(D.DiagnosticLoc); - if (D.MatchAnyLine) + OS << "\n File " << SourceMgr.getFilename(D->DiagnosticLoc); + if (D->MatchAnyLine) OS << " Line *"; else - OS << " Line " << SourceMgr.getPresumedLineNumber(D.DiagnosticLoc); - if (D.DirectiveLoc != D.DiagnosticLoc) + OS << " Line " << SourceMgr.getPresumedLineNumber(D->DiagnosticLoc); + if (D->DirectiveLoc != D->DiagnosticLoc) OS << " (directive at " - << SourceMgr.getFilename(D.DirectiveLoc) << ':' - << SourceMgr.getPresumedLineNumber(D.DirectiveLoc) << ')'; - OS << ": " << D.Text; + << SourceMgr.getFilename(D->DirectiveLoc) << ':' + << SourceMgr.getPresumedLineNumber(D->DirectiveLoc) << ')'; + OS << ": " << D->Text; } Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit() @@ -741,7 +771,6 @@ static bool IsFromSameFile(SourceManager &SM, SourceLocation DirectiveLoc, /// CheckLists - Compare expected to seen diagnostic lists and return the /// the difference between them. -/// static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const char *Label, DirectiveList &Left, @@ -792,7 +821,6 @@ static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr, /// CheckResults - This compares the expected results to those that /// were actually reported. It emits any discrepencies. Return "true" if there /// were problems. Return "false" otherwise. -/// static unsigned CheckResults(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const TextDiagnosticBuffer &Buffer, ExpectedData &ED) { @@ -875,19 +903,16 @@ void VerifyDiagnosticConsumer::CheckDiagnostics() { // this file is being parsed separately from the main file, in which // case consider moving the directives to the correct place, if this // is applicable. - if (UnparsedFiles.size() > 0) { + if (!UnparsedFiles.empty()) { // Generate a cache of parsed FileEntry pointers for alias lookups. llvm::SmallPtrSet ParsedFileCache; - for (ParsedFilesMap::iterator I = ParsedFiles.begin(), - End = ParsedFiles.end(); I != End; ++I) { - if (const FileEntry *FE = I->second) + for (const auto &I : ParsedFiles) + if (const FileEntry *FE = I.second) ParsedFileCache.insert(FE); - } // Iterate through list of unparsed files. - for (UnparsedFilesMap::iterator I = UnparsedFiles.begin(), - End = UnparsedFiles.end(); I != End; ++I) { - const UnparsedFileStatus &Status = I->second; + for (const auto &I : UnparsedFiles) { + const UnparsedFileStatus &Status = I.second; const FileEntry *FE = Status.getFile(); // Skip files that have been parsed via an alias. -- 2.7.4