From f06173045da016eb4a580be2a85da52a087ff72a Mon Sep 17 00:00:00 2001 From: Eugene Zelenko Date: Tue, 27 Mar 2018 00:01:49 +0000 Subject: [PATCH] [Edit, Rewrite] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@328597 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Edit/Commit.h | 36 ++++++--- include/clang/Edit/EditedSource.h | 36 +++++---- include/clang/Edit/EditsReceiver.h | 17 ++-- include/clang/Edit/FileOffset.h | 23 +++--- include/clang/Rewrite/Core/DeltaTree.h | 13 ++-- include/clang/Rewrite/Core/RewriteBuffer.h | 17 ++-- include/clang/Rewrite/Core/RewriteRope.h | 55 ++++++------- include/clang/Rewrite/Core/Rewriter.h | 42 +++++----- include/clang/Rewrite/Core/TokenRewriter.h | 28 +++---- .../clang/Rewrite/Frontend/FixItRewriter.h | 37 +++++---- lib/Edit/Commit.cpp | 19 +++-- lib/Edit/EditedSource.cpp | 13 +++- lib/Frontend/Rewrite/FixItRewriter.cpp | 29 ++++--- lib/Rewrite/DeltaTree.cpp | 48 ++++++------ lib/Rewrite/RewriteRope.cpp | 77 ++++++++++--------- lib/Rewrite/Rewriter.cpp | 40 ++++++---- lib/Rewrite/TokenRewriter.cpp | 15 ++-- 17 files changed, 307 insertions(+), 238 deletions(-) diff --git a/include/clang/Edit/Commit.h b/include/clang/Edit/Commit.h index ac4bb471fe..a574b8ef4c 100644 --- a/include/clang/Edit/Commit.h +++ b/include/clang/Edit/Commit.h @@ -1,4 +1,4 @@ -//===----- Commit.h - A unit of edits ---------------------------*- C++ -*-===// +//===- Commit.h - A unit of edits -------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -10,17 +10,22 @@ #ifndef LLVM_CLANG_EDIT_COMMIT_H #define LLVM_CLANG_EDIT_COMMIT_H +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Edit/FileOffset.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" namespace clang { - class LangOptions; - class PPConditionalDirectiveRecord; + +class LangOptions; +class PPConditionalDirectiveRecord; +class SourceManager; namespace edit { - class EditedSource; + +class EditedSource; class Commit { public: @@ -48,9 +53,9 @@ private: const SourceManager &SourceMgr; const LangOptions &LangOpts; const PPConditionalDirectiveRecord *PPRec; - EditedSource *Editor; + EditedSource *Editor = nullptr; - bool IsCommitable; + bool IsCommitable = true; SmallVector CachedEdits; llvm::BumpPtrAllocator StrAlloc; @@ -59,21 +64,23 @@ public: explicit Commit(EditedSource &Editor); Commit(const SourceManager &SM, const LangOptions &LangOpts, const PPConditionalDirectiveRecord *PPRec = nullptr) - : SourceMgr(SM), LangOpts(LangOpts), PPRec(PPRec), Editor(nullptr), - IsCommitable(true) { } + : SourceMgr(SM), LangOpts(LangOpts), PPRec(PPRec) {} bool isCommitable() const { return IsCommitable; } bool insert(SourceLocation loc, StringRef text, bool afterToken = false, bool beforePreviousInsertions = false); + bool insertAfterToken(SourceLocation loc, StringRef text, bool beforePreviousInsertions = false) { return insert(loc, text, /*afterToken=*/true, beforePreviousInsertions); } + bool insertBefore(SourceLocation loc, StringRef text) { return insert(loc, text, /*afterToken=*/false, /*beforePreviousInsertions=*/true); } + bool insertFromRange(SourceLocation loc, CharSourceRange range, bool afterToken = false, bool beforePreviousInsertions = false); @@ -92,21 +99,26 @@ public: return insertFromRange(loc, CharSourceRange::getTokenRange(TokenRange), afterToken, beforePreviousInsertions); } + bool insertWrap(StringRef before, SourceRange TokenRange, StringRef after) { return insertWrap(before, CharSourceRange::getTokenRange(TokenRange), after); } + bool remove(SourceRange TokenRange) { return remove(CharSourceRange::getTokenRange(TokenRange)); } + bool replace(SourceRange TokenRange, StringRef text) { return replace(CharSourceRange::getTokenRange(TokenRange), text); } + bool replaceWithInner(SourceRange TokenRange, SourceRange TokenInnerRange) { return replaceWithInner(CharSourceRange::getTokenRange(TokenRange), CharSourceRange::getTokenRange(TokenInnerRange)); } - typedef SmallVectorImpl::const_iterator edit_iterator; + using edit_iterator = SmallVectorImpl::const_iterator; + edit_iterator edit_begin() const { return CachedEdits.begin(); } edit_iterator edit_end() const { return CachedEdits.end(); } @@ -136,8 +148,8 @@ private: SourceLocation *MacroEnd = nullptr) const; }; -} +} // namespace edit -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_EDIT_COMMIT_H diff --git a/include/clang/Edit/EditedSource.h b/include/clang/Edit/EditedSource.h index d95a0c2be8..3d33688f5f 100644 --- a/include/clang/Edit/EditedSource.h +++ b/include/clang/Edit/EditedSource.h @@ -1,4 +1,4 @@ -//===----- EditedSource.h - Collection of source edits ----------*- C++ -*-===// +//===- EditedSource.h - Collection of source edits --------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -11,21 +11,27 @@ #define LLVM_CLANG_EDIT_EDITEDSOURCE_H #include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Edit/FileOffset.h" #include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" -#include "llvm/ADT/TinyPtrVector.h" #include "llvm/Support/Allocator.h" #include #include +#include namespace clang { - class LangOptions; - class PPConditionalDirectiveRecord; + +class LangOptions; +class PPConditionalDirectiveRecord; +class SourceManager; namespace edit { - class Commit; - class EditsReceiver; + +class Commit; +class EditsReceiver; class EditedSource { const SourceManager &SourceMgr; @@ -34,17 +40,19 @@ class EditedSource { struct FileEdit { StringRef Text; - unsigned RemoveLen; + unsigned RemoveLen = 0; - FileEdit() : RemoveLen(0) {} + FileEdit() = default; }; - typedef std::map FileEditsTy; + using FileEditsTy = std::map; + FileEditsTy FileEdits; struct MacroArgUse { IdentifierInfo *Identifier; SourceLocation ImmediateExpansionLoc; + // Location of argument use inside the top-level macro SourceLocation UseLoc; @@ -65,11 +73,11 @@ class EditedSource { public: EditedSource(const SourceManager &SM, const LangOptions &LangOpts, const PPConditionalDirectiveRecord *PPRec = nullptr) - : SourceMgr(SM), LangOpts(LangOpts), PPRec(PPRec), IdentTable(LangOpts), - StrAlloc() { } + : SourceMgr(SM), LangOpts(LangOpts), PPRec(PPRec), IdentTable(LangOpts) {} const SourceManager &getSourceManager() const { return SourceMgr; } const LangOptions &getLangOpts() const { return LangOpts; } + const PPConditionalDirectiveRecord *getPPCondDirectiveRecord() const { return PPRec; } @@ -103,8 +111,8 @@ private: void finishedCommit(); }; -} +} // namespace edit -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_EDIT_EDITEDSOURCE_H diff --git a/include/clang/Edit/EditsReceiver.h b/include/clang/Edit/EditsReceiver.h index 600ac28ea9..4fd4347915 100644 --- a/include/clang/Edit/EditsReceiver.h +++ b/include/clang/Edit/EditsReceiver.h @@ -1,4 +1,4 @@ -//===----- EditedSource.h - Collection of source edits ----------*- C++ -*-===// +//===- EditedSource.h - Collection of source edits --------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -11,25 +11,24 @@ #define LLVM_CLANG_EDIT_EDITSRECEIVER_H #include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/StringRef.h" namespace clang { - class SourceLocation; - class CharSourceRange; - namespace edit { class EditsReceiver { public: - virtual ~EditsReceiver() { } + virtual ~EditsReceiver() = default; virtual void insert(SourceLocation loc, StringRef text) = 0; virtual void replace(CharSourceRange range, StringRef text) = 0; + /// \brief By default it calls replace with an empty string. virtual void remove(CharSourceRange range); }; -} - -} // end namespace clang +} // namespace edit +} // namespace clang -#endif +#endif // LLVM_CLANG_EDIT_EDITSRECEIVER_H diff --git a/include/clang/Edit/FileOffset.h b/include/clang/Edit/FileOffset.h index 0c1e72b84e..02c1b96b33 100644 --- a/include/clang/Edit/FileOffset.h +++ b/include/clang/Edit/FileOffset.h @@ -1,4 +1,4 @@ -//===----- FileOffset.h - Offset in a file ----------------------*- C++ -*-===// +//===- FileOffset.h - Offset in a file --------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -11,17 +11,18 @@ #define LLVM_CLANG_EDIT_FILEOFFSET_H #include "clang/Basic/SourceLocation.h" +#include namespace clang { - namespace edit { class FileOffset { FileID FID; - unsigned Offs; + unsigned Offs = 0; + public: - FileOffset() : Offs(0) { } - FileOffset(FileID fid, unsigned offs) : FID(fid), Offs(offs) { } + FileOffset() = default; + FileOffset(FileID fid, unsigned offs) : FID(fid), Offs(offs) {} bool isInvalid() const { return FID.isInvalid(); } @@ -37,25 +38,29 @@ public: friend bool operator==(FileOffset LHS, FileOffset RHS) { return LHS.FID == RHS.FID && LHS.Offs == RHS.Offs; } + friend bool operator!=(FileOffset LHS, FileOffset RHS) { return !(LHS == RHS); } + friend bool operator<(FileOffset LHS, FileOffset RHS) { return std::tie(LHS.FID, LHS.Offs) < std::tie(RHS.FID, RHS.Offs); } + friend bool operator>(FileOffset LHS, FileOffset RHS) { return RHS < LHS; } + friend bool operator>=(FileOffset LHS, FileOffset RHS) { return !(LHS < RHS); } + friend bool operator<=(FileOffset LHS, FileOffset RHS) { return !(RHS < LHS); } }; -} - -} // end namespace clang +} // namespace edit +} // namespace clang -#endif +#endif // LLVM_CLANG_EDIT_FILEOFFSET_H diff --git a/include/clang/Rewrite/Core/DeltaTree.h b/include/clang/Rewrite/Core/DeltaTree.h index fbffb38e37..f798e9fc41 100644 --- a/include/clang/Rewrite/Core/DeltaTree.h +++ b/include/clang/Rewrite/Core/DeltaTree.h @@ -1,4 +1,4 @@ -//===--- DeltaTree.h - B-Tree for Rewrite Delta tracking --------*- C++ -*-===// +//===- DeltaTree.h - B-Tree for Rewrite Delta tracking ----------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -14,8 +14,6 @@ #ifndef LLVM_CLANG_REWRITE_CORE_DELTATREE_H #define LLVM_CLANG_REWRITE_CORE_DELTATREE_H -#include "llvm/Support/Compiler.h" - namespace clang { /// DeltaTree - a multiway search tree (BTree) structure with some fancy @@ -27,12 +25,14 @@ namespace clang { /// as well, without traversing the whole tree. class DeltaTree { void *Root; // "DeltaTreeNode *" - void operator=(const DeltaTree &) = delete; + public: DeltaTree(); // Note: Currently we only support copying when the RHS is empty. DeltaTree(const DeltaTree &RHS); + + DeltaTree &operator=(const DeltaTree &) = delete; ~DeltaTree(); /// getDeltaAt - Return the accumulated delta at the specified file offset. @@ -45,6 +45,7 @@ namespace clang { /// into the current DeltaTree at offset FileIndex. void AddDelta(unsigned FileIndex, int Delta); }; -} // end namespace clang -#endif +} // namespace clang + +#endif // LLVM_CLANG_REWRITE_CORE_DELTATREE_H diff --git a/include/clang/Rewrite/Core/RewriteBuffer.h b/include/clang/Rewrite/Core/RewriteBuffer.h index d69c69b81e..1e6905486c 100644 --- a/include/clang/Rewrite/Core/RewriteBuffer.h +++ b/include/clang/Rewrite/Core/RewriteBuffer.h @@ -1,4 +1,4 @@ -//===--- RewriteBuffer.h - Buffer rewriting interface -----------*- C++ -*-===// +//===- RewriteBuffer.h - Buffer rewriting interface -------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -16,7 +16,6 @@ #include "llvm/ADT/StringRef.h" namespace clang { - class Rewriter; /// RewriteBuffer - As code is rewritten, SourceBuffer's from the original /// input with modifications get a new RewriteBuffer associated with them. The @@ -26,12 +25,16 @@ namespace clang { /// locations after the insertion point have to be mapped. class RewriteBuffer { friend class Rewriter; + /// Deltas - Keep track of all the deltas in the source code due to insertions /// and deletions. DeltaTree Deltas; + RewriteRope Buffer; + public: - typedef RewriteRope::const_iterator iterator; + using iterator = RewriteRope::const_iterator; + iterator begin() const { return Buffer.begin(); } iterator end() const { return Buffer.end(); } unsigned size() const { return Buffer.size(); } @@ -61,7 +64,6 @@ public: /// InsertText - Insert some text at the specified point, where the offset in /// the buffer is specified relative to the original SourceBuffer. The /// text is inserted after the specified location. - /// void InsertText(unsigned OrigOffset, StringRef Str, bool InsertAfter = true); @@ -87,8 +89,7 @@ public: void ReplaceText(unsigned OrigOffset, unsigned OrigLength, StringRef NewStr); -private: // Methods only usable by Rewriter. - +private: /// getMappedOffset - Given an offset into the original SourceBuffer that this /// RewriteBuffer is based on, map it into the offset space of the /// RewriteBuffer. If AfterInserts is true and if the OrigOffset indicates a @@ -112,6 +113,6 @@ private: // Methods only usable by Rewriter. } }; -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_REWRITE_CORE_REWRITEBUFFER_H diff --git a/include/clang/Rewrite/Core/RewriteRope.h b/include/clang/Rewrite/Core/RewriteRope.h index 5002554485..2a0e0a4a63 100644 --- a/include/clang/Rewrite/Core/RewriteRope.h +++ b/include/clang/Rewrite/Core/RewriteRope.h @@ -1,4 +1,4 @@ -//===--- RewriteRope.h - Rope specialized for rewriter ----------*- C++ -*-===// +//===- RewriteRope.h - Rope specialized for rewriter ------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -16,13 +16,13 @@ #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/StringRef.h" -#include "llvm/Support/Compiler.h" #include #include -#include #include +#include namespace clang { + //===--------------------------------------------------------------------===// // RopeRefCountString Class //===--------------------------------------------------------------------===// @@ -58,11 +58,10 @@ namespace clang { /// different offsets) which is a nice constant time operation. struct RopePiece { llvm::IntrusiveRefCntPtr StrData; - unsigned StartOffs; - unsigned EndOffs; - - RopePiece() : StrData(nullptr), StartOffs(0), EndOffs(0) {} + unsigned StartOffs = 0; + unsigned EndOffs = 0; + RopePiece() = default; RopePiece(llvm::IntrusiveRefCntPtr Str, unsigned Start, unsigned End) : StrData(std::move(Str)), StartOffs(Start), EndOffs(End) {} @@ -88,18 +87,18 @@ namespace clang { class RopePieceBTreeIterator : public std::iterator { /// CurNode - The current B+Tree node that we are inspecting. - const void /*RopePieceBTreeLeaf*/ *CurNode; + const void /*RopePieceBTreeLeaf*/ *CurNode = nullptr; + /// CurPiece - The current RopePiece in the B+Tree node that we're /// inspecting. - const RopePiece *CurPiece; + const RopePiece *CurPiece = nullptr; + /// CurChar - The current byte in the RopePiece we are pointing to. - unsigned CurChar; + unsigned CurChar = 0; + public: - // begin iterator. + RopePieceBTreeIterator() = default; RopePieceBTreeIterator(const void /*RopePieceBTreeNode*/ *N); - // end iterator - RopePieceBTreeIterator() - : CurNode(nullptr), CurPiece(nullptr), CurChar(0) {} char operator*() const { return (*CurPiece)[CurChar]; @@ -119,7 +118,8 @@ namespace clang { MoveToNextPiece(); return *this; } - inline RopePieceBTreeIterator operator++(int) { // Postincrement + + RopePieceBTreeIterator operator++(int) { // Postincrement RopePieceBTreeIterator tmp = *this; ++*this; return tmp; } @@ -136,13 +136,15 @@ namespace clang { class RopePieceBTree { void /*RopePieceBTreeNode*/ *Root; - void operator=(const RopePieceBTree &) = delete; + public: RopePieceBTree(); RopePieceBTree(const RopePieceBTree &RHS); + RopePieceBTree &operator=(const RopePieceBTree &) = delete; ~RopePieceBTree(); - typedef RopePieceBTreeIterator iterator; + using iterator = RopePieceBTreeIterator; + iterator begin() const { return iterator(Root); } iterator end() const { return iterator(); } unsigned size() const; @@ -168,19 +170,18 @@ class RewriteRope { /// We allocate space for string data out of a buffer of size AllocChunkSize. /// This keeps track of how much space is left. llvm::IntrusiveRefCntPtr AllocBuffer; - unsigned AllocOffs; enum { AllocChunkSize = 4080 }; + unsigned AllocOffs = AllocChunkSize; public: - RewriteRope() : AllocBuffer(nullptr), AllocOffs(AllocChunkSize) {} - RewriteRope(const RewriteRope &RHS) - : Chunks(RHS.Chunks), AllocBuffer(nullptr), AllocOffs(AllocChunkSize) { - } + RewriteRope() = default; + RewriteRope(const RewriteRope &RHS) : Chunks(RHS.Chunks) {} + + using iterator = RopePieceBTree::iterator; + using const_iterator = RopePieceBTree::iterator; - typedef RopePieceBTree::iterator iterator; - typedef RopePieceBTree::iterator const_iterator; iterator begin() const { return Chunks.begin(); } - iterator end() const { return Chunks.end(); } + iterator end() const { return Chunks.end(); } unsigned size() const { return Chunks.size(); } void clear() { @@ -209,6 +210,6 @@ private: RopePiece MakeRopeString(const char *Start, const char *End); }; -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_REWRITE_CORE_REWRITEROPE_H diff --git a/include/clang/Rewrite/Core/Rewriter.h b/include/clang/Rewrite/Core/Rewriter.h index 800372ea55..cf33cd6705 100644 --- a/include/clang/Rewrite/Core/Rewriter.h +++ b/include/clang/Rewrite/Core/Rewriter.h @@ -1,4 +1,4 @@ -//===--- Rewriter.h - Code rewriting interface ------------------*- C++ -*-===// +//===- Rewriter.h - Code rewriting interface --------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -15,52 +15,55 @@ #ifndef LLVM_CLANG_REWRITE_CORE_REWRITER_H #define LLVM_CLANG_REWRITE_CORE_REWRITER_H +#include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" #include "clang/Rewrite/Core/RewriteBuffer.h" -#include +#include "llvm/ADT/StringRef.h" #include #include namespace clang { - class LangOptions; - class SourceManager; + +class LangOptions; +class SourceManager; /// Rewriter - This is the main interface to the rewrite buffers. Its primary /// job is to dispatch high-level requests to the low-level RewriteBuffers that /// are involved. class Rewriter { - SourceManager *SourceMgr; - const LangOptions *LangOpts; + SourceManager *SourceMgr = nullptr; + const LangOptions *LangOpts = nullptr; std::map RewriteBuffers; + public: struct RewriteOptions { /// \brief Given a source range, true to include previous inserts at the /// beginning of the range as part of the range itself (true by default). - bool IncludeInsertsAtBeginOfRange; + bool IncludeInsertsAtBeginOfRange = true; + /// \brief Given a source range, true to include previous inserts at the /// end of the range as part of the range itself (true by default). - bool IncludeInsertsAtEndOfRange; + bool IncludeInsertsAtEndOfRange = true; + /// \brief If true and removing some text leaves a blank line /// also remove the empty line (false by default). - bool RemoveLineIfEmpty; + bool RemoveLineIfEmpty = false; - RewriteOptions() - : IncludeInsertsAtBeginOfRange(true), - IncludeInsertsAtEndOfRange(true), - RemoveLineIfEmpty(false) { } + RewriteOptions() {} }; - typedef std::map::iterator buffer_iterator; - typedef std::map::const_iterator const_buffer_iterator; + using buffer_iterator = std::map::iterator; + using const_buffer_iterator = std::map::const_iterator; + explicit Rewriter() = default; explicit Rewriter(SourceManager &SM, const LangOptions &LO) - : SourceMgr(&SM), LangOpts(&LO) {} - explicit Rewriter() : SourceMgr(nullptr), LangOpts(nullptr) {} + : SourceMgr(&SM), LangOpts(&LO) {} void setSourceMgr(SourceManager &SM, const LangOptions &LO) { SourceMgr = &SM; LangOpts = &LO; } + SourceManager &getSourceMgr() const { return *SourceMgr; } const LangOptions &getLangOpts() const { return *LangOpts; } @@ -82,7 +85,6 @@ public: /// in different buffers, this returns an empty string. /// /// Note that this method is not particularly efficient. - /// std::string getRewrittenText(SourceRange Range) const; /// InsertText - Insert the specified string at the specified location in the @@ -190,6 +192,6 @@ private: unsigned getLocationOffsetAndFileID(SourceLocation Loc, FileID &FID) const; }; -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_REWRITE_CORE_REWRITER_H diff --git a/include/clang/Rewrite/Core/TokenRewriter.h b/include/clang/Rewrite/Core/TokenRewriter.h index 0f71e81c31..ab2c2c8b0a 100644 --- a/include/clang/Rewrite/Core/TokenRewriter.h +++ b/include/clang/Rewrite/Core/TokenRewriter.h @@ -1,4 +1,4 @@ -//===--- TokenRewriter.h - Token-based Rewriter -----------------*- C++ -*-===// +//===- TokenRewriter.h - Token-based Rewriter -------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -17,13 +17,16 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Lex/Token.h" +#include #include #include #include namespace clang { - class LangOptions; - class ScratchBuffer; + +class LangOptions; +class ScratchBuffer; +class SourceManager; class TokenRewriter { /// TokenList - This is the list of raw tokens that make up this file. Each @@ -31,7 +34,7 @@ namespace clang { std::list TokenList; /// TokenRefTy - This is the type used to refer to a token in the TokenList. - typedef std::list::iterator TokenRefTy; + using TokenRefTy = std::list::iterator; /// TokenAtLoc - This map indicates which token exists at a specific /// SourceLocation. Since each token has a unique SourceLocation, this is a @@ -40,23 +43,24 @@ namespace clang { std::map TokenAtLoc; /// ScratchBuf - This is the buffer that we create scratch tokens from. - /// std::unique_ptr ScratchBuf; - TokenRewriter(const TokenRewriter &) = delete; - void operator=(const TokenRewriter &) = delete; public: /// TokenRewriter - This creates a TokenRewriter for the file with the /// specified FileID. TokenRewriter(FileID FID, SourceManager &SM, const LangOptions &LO); + + TokenRewriter(const TokenRewriter &) = delete; + TokenRewriter &operator=(const TokenRewriter &) = delete; ~TokenRewriter(); - typedef std::list::const_iterator token_iterator; + using token_iterator = std::list::const_iterator; + token_iterator token_begin() const { return TokenList.begin(); } token_iterator token_end() const { return TokenList.end(); } - token_iterator AddTokenBefore(token_iterator I, const char *Val); + token_iterator AddTokenAfter(token_iterator I, const char *Val) { assert(I != token_end() && "Cannot insert after token_end()!"); return AddTokenBefore(++I, Val); @@ -72,8 +76,6 @@ namespace clang { TokenRefTy AddToken(const Token &T, TokenRefTy Where); }; +} // namespace clang - -} // end namespace clang - -#endif +#endif // LLVM_CLANG_REWRITE_CORE_TOKENREWRITER_H diff --git a/include/clang/Rewrite/Frontend/FixItRewriter.h b/include/clang/Rewrite/Frontend/FixItRewriter.h index 3b1b31e0cd..18ab776c2b 100644 --- a/include/clang/Rewrite/Frontend/FixItRewriter.h +++ b/include/clang/Rewrite/Frontend/FixItRewriter.h @@ -1,4 +1,4 @@ -//===--- FixItRewriter.h - Fix-It Rewriter Diagnostic Client ----*- C++ -*-===// +//===- FixItRewriter.h - Fix-It Rewriter Diagnostic Client ------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -12,24 +12,28 @@ // then forwards any diagnostics to the adapted diagnostic client. // //===----------------------------------------------------------------------===// + #ifndef LLVM_CLANG_REWRITE_FRONTEND_FIXITREWRITER_H #define LLVM_CLANG_REWRITE_FRONTEND_FIXITREWRITER_H #include "clang/Basic/Diagnostic.h" +#include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" #include "clang/Edit/EditedSource.h" #include "clang/Rewrite/Core/Rewriter.h" +#include +#include +#include +#include namespace clang { +class LangOptions; class SourceManager; -class FileEntry; class FixItOptions { public: - FixItOptions() : InPlace(false), FixWhatYouCan(false), - FixOnlyWarnings(false), Silent(false) { } - + FixItOptions() = default; virtual ~FixItOptions(); /// \brief This file is about to be rewritten. Return the name of the file @@ -38,23 +42,22 @@ public: /// \param fd out parameter for file descriptor. After the call it may be set /// to an open file descriptor for the returned filename, or it will be -1 /// otherwise. - /// virtual std::string RewriteFilename(const std::string &Filename, int &fd) = 0; /// True if files should be updated in place. RewriteFilename is only called /// if this is false. - bool InPlace; + bool InPlace = false; /// \brief Whether to abort fixing a file when not all errors could be fixed. - bool FixWhatYouCan; + bool FixWhatYouCan = false; /// \brief Whether to only fix warnings and not errors. - bool FixOnlyWarnings; + bool FixOnlyWarnings = false; /// \brief If true, only pass the diagnostic to the actual diagnostic consumer /// if it is an error or a fixit was applied as part of the diagnostic. /// It basically silences warnings without accompanying fixits. - bool Silent; + bool Silent = false; }; class FixItRewriter : public DiagnosticConsumer { @@ -77,14 +80,12 @@ class FixItRewriter : public DiagnosticConsumer { FixItOptions *FixItOpts; /// \brief The number of rewriter failures. - unsigned NumFailures; + unsigned NumFailures = 0; /// \brief Whether the previous diagnostic was not passed to the consumer. - bool PrevDiagSilenced; + bool PrevDiagSilenced = false; public: - typedef Rewriter::buffer_iterator iterator; - /// \brief Initialize a new fix-it rewriter. FixItRewriter(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const LangOptions &LangOpts, FixItOptions *FixItOpts); @@ -97,6 +98,8 @@ public: return Rewrite.getRewriteBufferFor(ID) != nullptr; } + using iterator = Rewriter::buffer_iterator; + // Iteration over files with changes. iterator buffer_begin() { return Rewrite.buffer_begin(); } iterator buffer_end() { return Rewrite.buffer_end(); } @@ -110,7 +113,7 @@ public: /// /// \returns true if there was an error, false otherwise. bool WriteFixedFiles( - std::vector > *RewrittenFiles=nullptr); + std::vector> *RewrittenFiles = nullptr); /// IncludeInDiagnosticCounts - This method (whose default implementation /// returns true) indicates whether the diagnostics handled by this @@ -127,6 +130,6 @@ public: void Diag(SourceLocation Loc, unsigned DiagID); }; -} +} // namespace clang -#endif +#endif // LLVM_CLANG_REWRITE_FRONTEND_FIXITREWRITER_H diff --git a/lib/Edit/Commit.cpp b/lib/Edit/Commit.cpp index 0cc152bf1e..afc1a131eb 100644 --- a/lib/Edit/Commit.cpp +++ b/lib/Edit/Commit.cpp @@ -1,4 +1,4 @@ -//===----- Commit.cpp - A unit of edits -----------------------------------===// +//===- Commit.cpp - A unit of edits ---------------------------------------===// // // The LLVM Compiler Infrastructure // @@ -8,10 +8,16 @@ //===----------------------------------------------------------------------===// #include "clang/Edit/Commit.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Edit/EditedSource.h" +#include "clang/Edit/FileOffset.h" #include "clang/Lex/Lexer.h" #include "clang/Lex/PPConditionalDirectiveRecord.h" +#include "llvm/ADT/StringRef.h" +#include +#include using namespace clang; using namespace edit; @@ -36,9 +42,9 @@ CharSourceRange Commit::Edit::getInsertFromRange(SourceManager &SM) const { } Commit::Commit(EditedSource &Editor) - : SourceMgr(Editor.getSourceManager()), LangOpts(Editor.getLangOpts()), - PPRec(Editor.getPPCondDirectiveRecord()), - Editor(&Editor), IsCommitable(true) { } + : SourceMgr(Editor.getSourceManager()), LangOpts(Editor.getLangOpts()), + PPRec(Editor.getPPCondDirectiveRecord()), + Editor(&Editor) {} bool Commit::insert(SourceLocation loc, StringRef text, bool afterToken, bool beforePreviousInsertions) { @@ -276,14 +282,12 @@ bool Commit::canInsertAfterToken(SourceLocation loc, FileOffset &offs, } bool Commit::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) { - for (unsigned i = 0, e = CachedEdits.size(); i != e; ++i) { - Edit &act = CachedEdits[i]; + for (const auto &act : CachedEdits) if (act.Kind == Act_Remove) { if (act.Offset.getFID() == Offs.getFID() && Offs > act.Offset && Offs < act.Offset.getWithOffset(act.Length)) return false; // position has been removed. } - } if (!Editor) return true; @@ -338,6 +342,7 @@ bool Commit::isAtStartOfMacroExpansion(SourceLocation loc, SourceLocation *MacroBegin) const { return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, LangOpts, MacroBegin); } + bool Commit::isAtEndOfMacroExpansion(SourceLocation loc, SourceLocation *MacroEnd) const { return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, LangOpts, MacroEnd); diff --git a/lib/Edit/EditedSource.cpp b/lib/Edit/EditedSource.cpp index 444d0393cc..0ff2447f77 100644 --- a/lib/Edit/EditedSource.cpp +++ b/lib/Edit/EditedSource.cpp @@ -1,4 +1,4 @@ -//===----- EditedSource.cpp - Collection of source edits ------------------===// +//===- EditedSource.cpp - Collection of source edits ----------------------===// // // The LLVM Compiler Infrastructure // @@ -9,12 +9,21 @@ #include "clang/Edit/EditedSource.h" #include "clang/Basic/CharInfo.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Edit/Commit.h" #include "clang/Edit/EditsReceiver.h" +#include "clang/Edit/FileOffset.h" #include "clang/Lex/Lexer.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" +#include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" +#include +#include +#include +#include using namespace clang; using namespace edit; @@ -269,9 +278,11 @@ bool EditedSource::commit(const Commit &commit) { struct CommitRAII { EditedSource &Editor; + CommitRAII(EditedSource &Editor) : Editor(Editor) { Editor.startingCommit(); } + ~CommitRAII() { Editor.finishedCommit(); } diff --git a/lib/Frontend/Rewrite/FixItRewriter.cpp b/lib/Frontend/Rewrite/FixItRewriter.cpp index dc787ac955..17a35c3ac9 100644 --- a/lib/Frontend/Rewrite/FixItRewriter.cpp +++ b/lib/Frontend/Rewrite/FixItRewriter.cpp @@ -1,4 +1,4 @@ -//===--- FixItRewriter.cpp - Fix-It Rewriter Diagnostic Client --*- C++ -*-===// +//===- FixItRewriter.cpp - Fix-It Rewriter Diagnostic Client --------------===// // // The LLVM Compiler Infrastructure // @@ -14,28 +14,32 @@ //===----------------------------------------------------------------------===// #include "clang/Rewrite/Frontend/FixItRewriter.h" +#include "clang/Basic/Diagnostic.h" #include "clang/Basic/FileManager.h" +#include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Edit/Commit.h" #include "clang/Edit/EditsReceiver.h" #include "clang/Frontend/FrontendDiagnostic.h" -#include "llvm/Support/Path.h" +#include "clang/Rewrite/Core/RewriteBuffer.h" +#include "clang/Rewrite/Core/Rewriter.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/FileSystem.h" #include "llvm/Support/raw_ostream.h" #include #include +#include +#include +#include using namespace clang; FixItRewriter::FixItRewriter(DiagnosticsEngine &Diags, SourceManager &SourceMgr, const LangOptions &LangOpts, FixItOptions *FixItOpts) - : Diags(Diags), - Editor(SourceMgr, LangOpts), - Rewrite(SourceMgr, LangOpts), - FixItOpts(FixItOpts), - NumFailures(0), - PrevDiagSilenced(false) { + : Diags(Diags), Editor(SourceMgr, LangOpts), Rewrite(SourceMgr, LangOpts), + FixItOpts(FixItOpts) { Owner = Diags.takeClient(); Client = Diags.getClient(); Diags.setClient(this, false); @@ -59,20 +63,21 @@ class RewritesReceiver : public edit::EditsReceiver { Rewriter &Rewrite; public: - RewritesReceiver(Rewriter &Rewrite) : Rewrite(Rewrite) { } + RewritesReceiver(Rewriter &Rewrite) : Rewrite(Rewrite) {} void insert(SourceLocation loc, StringRef text) override { Rewrite.InsertText(loc, text); } + void replace(CharSourceRange range, StringRef text) override { Rewrite.ReplaceText(range.getBegin(), Rewrite.getRangeSize(range), text); } }; -} +} // namespace bool FixItRewriter::WriteFixedFiles( - std::vector > *RewrittenFiles) { + std::vector> *RewrittenFiles) { if (NumFailures > 0 && !FixItOpts->FixWhatYouCan) { Diag(FullSourceLoc(), diag::warn_fixit_no_changes); return true; @@ -200,4 +205,4 @@ void FixItRewriter::Diag(SourceLocation Loc, unsigned DiagID) { Diags.setClient(this, false); } -FixItOptions::~FixItOptions() {} +FixItOptions::~FixItOptions() = default; diff --git a/lib/Rewrite/DeltaTree.cpp b/lib/Rewrite/DeltaTree.cpp index 352fab077a..1dfc26cc91 100644 --- a/lib/Rewrite/DeltaTree.cpp +++ b/lib/Rewrite/DeltaTree.cpp @@ -1,4 +1,4 @@ -//===--- DeltaTree.cpp - B-Tree for Rewrite Delta tracking ----------------===// +//===- DeltaTree.cpp - B-Tree for Rewrite Delta tracking ------------------===// // // The LLVM Compiler Infrastructure // @@ -13,8 +13,10 @@ #include "clang/Rewrite/Core/DeltaTree.h" #include "clang/Basic/LLVM.h" -#include +#include "llvm/Support/Casting.h" +#include #include + using namespace clang; /// The DeltaTree class is a multiway search tree (BTree) structure with some @@ -33,6 +35,7 @@ using namespace clang; /// full delta implied by a whole subtree in constant time. namespace { + /// SourceDelta - As code in the original input buffer is added and deleted, /// SourceDelta records are used to keep track of how the input SourceLocation /// object is mapped into the output buffer. @@ -67,12 +70,11 @@ namespace { enum { WidthFactor = 8 }; /// Values - This tracks the SourceDelta's currently in this node. - /// SourceDelta Values[2*WidthFactor-1]; /// NumValuesUsed - This tracks the number of values this node currently /// holds. - unsigned char NumValuesUsed; + unsigned char NumValuesUsed = 0; /// IsLeaf - This is true if this is a leaf of the btree. If false, this is /// an interior node, and is actually an instance of DeltaTreeInteriorNode. @@ -80,20 +82,22 @@ namespace { /// FullDelta - This is the full delta of all the values in this node and /// all children nodes. - int FullDelta; + int FullDelta = 0; + public: - DeltaTreeNode(bool isLeaf = true) - : NumValuesUsed(0), IsLeaf(isLeaf), FullDelta(0) {} + DeltaTreeNode(bool isLeaf = true) : IsLeaf(isLeaf) {} bool isLeaf() const { return IsLeaf; } int getFullDelta() const { return FullDelta; } bool isFull() const { return NumValuesUsed == 2*WidthFactor-1; } unsigned getNumValuesUsed() const { return NumValuesUsed; } + const SourceDelta &getValue(unsigned i) const { assert(i < NumValuesUsed && "Invalid value #"); return Values[i]; } + SourceDelta &getValue(unsigned i) { assert(i < NumValuesUsed && "Invalid value #"); return Values[i]; @@ -114,23 +118,24 @@ namespace { void Destroy(); }; -} // end anonymous namespace -namespace { /// DeltaTreeInteriorNode - When isLeaf = false, a node has child pointers. /// This class tracks them. class DeltaTreeInteriorNode : public DeltaTreeNode { + friend class DeltaTreeNode; + DeltaTreeNode *Children[2*WidthFactor]; + ~DeltaTreeInteriorNode() { for (unsigned i = 0, e = NumValuesUsed+1; i != e; ++i) Children[i]->Destroy(); } - friend class DeltaTreeNode; + public: DeltaTreeInteriorNode() : DeltaTreeNode(false /*nonleaf*/) {} DeltaTreeInteriorNode(const InsertResult &IR) - : DeltaTreeNode(false /*nonleaf*/) { + : DeltaTreeNode(false /*nonleaf*/) { Children[0] = IR.LHS; Children[1] = IR.RHS; Values[0] = IR.Split; @@ -142,15 +147,16 @@ namespace { assert(i < getNumValuesUsed()+1 && "Invalid child"); return Children[i]; } + DeltaTreeNode *getChild(unsigned i) { assert(i < getNumValuesUsed()+1 && "Invalid child"); return Children[i]; } - static inline bool classof(const DeltaTreeNode *N) { return !N->isLeaf(); } + static bool classof(const DeltaTreeNode *N) { return !N->isLeaf(); } }; -} +} // namespace /// Destroy - A 'virtual' destructor. void DeltaTreeNode::Destroy() { @@ -166,7 +172,7 @@ void DeltaTreeNode::RecomputeFullDeltaLocally() { int NewFullDelta = 0; for (unsigned i = 0, e = getNumValuesUsed(); i != e; ++i) NewFullDelta += Values[i].Delta; - if (DeltaTreeInteriorNode *IN = dyn_cast(this)) + if (auto *IN = dyn_cast(this)) for (unsigned i = 0, e = getNumValuesUsed()+1; i != e; ++i) NewFullDelta += IN->getChild(i)->getFullDelta(); FullDelta = NewFullDelta; @@ -223,7 +229,7 @@ bool DeltaTreeNode::DoInsertion(unsigned FileIndex, int Delta, } // Otherwise, this is an interior node. Send the request down the tree. - DeltaTreeInteriorNode *IN = cast(this); + auto *IN = cast(this); if (!IN->Children[i]->DoInsertion(FileIndex, Delta, InsertRes)) return false; // If there was space in the child, just return. @@ -300,7 +306,7 @@ void DeltaTreeNode::DoSplit(InsertResult &InsertRes) { // Create the new child node. DeltaTreeNode *NewNode; - if (DeltaTreeInteriorNode *IN = dyn_cast(this)) { + if (auto *IN = dyn_cast(this)) { // If this is an interior node, also move over 'WidthFactor' children // into the new node. DeltaTreeInteriorNode *New = new DeltaTreeInteriorNode(); @@ -328,8 +334,6 @@ void DeltaTreeNode::DoSplit(InsertResult &InsertRes) { InsertRes.Split = Values[WidthFactor-1]; } - - //===----------------------------------------------------------------------===// // DeltaTree Implementation //===----------------------------------------------------------------------===// @@ -340,7 +344,7 @@ void DeltaTreeNode::DoSplit(InsertResult &InsertRes) { /// VerifyTree - Walk the btree performing assertions on various properties to /// verify consistency. This is useful for debugging new changes to the tree. static void VerifyTree(const DeltaTreeNode *N) { - const DeltaTreeInteriorNode *IN = dyn_cast(N); + const auto *IN = dyn_cast(N); if (IN == 0) { // Verify leaves, just ensure that FullDelta matches up and the elements // are in proper order. @@ -387,6 +391,7 @@ static DeltaTreeNode *getRoot(void *Root) { DeltaTree::DeltaTree() { Root = new DeltaTreeNode(); } + DeltaTree::DeltaTree(const DeltaTree &RHS) { // Currently we only support copying when the RHS is empty. assert(getRoot(RHS.Root)->getNumValuesUsed() == 0 && @@ -407,7 +412,7 @@ int DeltaTree::getDeltaAt(unsigned FileIndex) const { int Result = 0; // Walk down the tree. - while (1) { + while (true) { // For all nodes, include any local deltas before the specified file // index by summing them up directly. Keep track of how many were // included. @@ -423,7 +428,7 @@ int DeltaTree::getDeltaAt(unsigned FileIndex) const { // If we have an interior node, include information about children and // recurse. Otherwise, if we have a leaf, we're done. - const DeltaTreeInteriorNode *IN = dyn_cast(Node); + const auto *IN = dyn_cast(Node); if (!IN) return Result; // Include any children to the left of the values we skipped, all of @@ -461,4 +466,3 @@ void DeltaTree::AddDelta(unsigned FileIndex, int Delta) { VerifyTree(MyRoot); #endif } - diff --git a/lib/Rewrite/RewriteRope.cpp b/lib/Rewrite/RewriteRope.cpp index 030ab7732f..5bc79f3edd 100644 --- a/lib/Rewrite/RewriteRope.cpp +++ b/lib/Rewrite/RewriteRope.cpp @@ -1,4 +1,4 @@ -//===--- RewriteRope.cpp - Rope specialized for rewriter --------*- C++ -*-===// +//===- RewriteRope.cpp - Rope specialized for rewriter --------------------===// // // The LLVM Compiler Infrastructure // @@ -13,7 +13,11 @@ #include "clang/Rewrite/Core/RewriteRope.h" #include "clang/Basic/LLVM.h" +#include "llvm/Support/Casting.h" #include +#include +#include + using namespace clang; /// RewriteRope is a "strong" string class, designed to make insertions and @@ -59,12 +63,12 @@ using namespace clang; /// RopePieceBTreeInterior - An interior node in the B+ Tree, which manages /// up to '2*WidthFactor' other nodes in the tree. +namespace { //===----------------------------------------------------------------------===// // RopePieceBTreeNode Class //===----------------------------------------------------------------------===// -namespace { /// RopePieceBTreeNode - Common base class of RopePieceBTreeLeaf and /// RopePieceBTreeInterior. This provides some 'virtual' dispatching methods /// and a flag that determines which subclass the instance is. Also @@ -82,13 +86,13 @@ namespace { /// Size - This is the number of bytes of file this node (including any /// potential children) covers. - unsigned Size; + unsigned Size = 0; /// IsLeaf - True if this is an instance of RopePieceBTreeLeaf, false if it /// is an instance of RopePieceBTreeInterior. bool IsLeaf; - RopePieceBTreeNode(bool isLeaf) : Size(0), IsLeaf(isLeaf) {} + RopePieceBTreeNode(bool isLeaf) : IsLeaf(isLeaf) {} ~RopePieceBTreeNode() = default; public: @@ -116,15 +120,12 @@ namespace { /// erase - Remove NumBytes from this node at the specified offset. We are /// guaranteed that there is a split at Offset. void erase(unsigned Offset, unsigned NumBytes); - }; -} // end anonymous namespace //===----------------------------------------------------------------------===// // RopePieceBTreeLeaf Class //===----------------------------------------------------------------------===// -namespace { /// RopePieceBTreeLeaf - Directly manages up to '2*WidthFactor' RopePiece /// nodes. This directly represents a chunk of the string with those /// RopePieces contatenated. Since this is a B+Tree, all values (in this case @@ -135,18 +136,19 @@ namespace { class RopePieceBTreeLeaf : public RopePieceBTreeNode { /// NumPieces - This holds the number of rope pieces currently active in the /// Pieces array. - unsigned char NumPieces; + unsigned char NumPieces = 0; /// Pieces - This tracks the file chunks currently in this leaf. - /// RopePiece Pieces[2*WidthFactor]; /// NextLeaf - This is a pointer to the next leaf in the tree, allowing /// efficient in-order forward iteration of the tree without traversal. - RopePieceBTreeLeaf **PrevLeaf, *NextLeaf; + RopePieceBTreeLeaf **PrevLeaf = nullptr; + RopePieceBTreeLeaf *NextLeaf = nullptr; + public: - RopePieceBTreeLeaf() : RopePieceBTreeNode(true), NumPieces(0), - PrevLeaf(nullptr), NextLeaf(nullptr) {} + RopePieceBTreeLeaf() : RopePieceBTreeNode(true) {} + ~RopePieceBTreeLeaf() { if (PrevLeaf || NextLeaf) removeFromLeafInOrder(); @@ -170,6 +172,7 @@ namespace { } const RopePieceBTreeLeaf *getNextLeafInOrder() const { return NextLeaf; } + void insertAfterLeafInOrder(RopePieceBTreeLeaf *Node) { assert(!PrevLeaf && !NextLeaf && "Already in ordering"); @@ -214,16 +217,16 @@ namespace { /// node is returned and must be inserted into a parent. RopePieceBTreeNode *insert(unsigned Offset, const RopePiece &R); - /// erase - Remove NumBytes from this node at the specified offset. We are /// guaranteed that there is a split at Offset. void erase(unsigned Offset, unsigned NumBytes); - static inline bool classof(const RopePieceBTreeNode *N) { + static bool classof(const RopePieceBTreeNode *N) { return N->isLeaf(); } }; -} // end anonymous namespace + +} // namespace /// split - Split the range containing the specified offset so that we are /// guaranteed that there is a place to do an insertion at the specified @@ -266,7 +269,6 @@ RopePieceBTreeNode *RopePieceBTreeLeaf::split(unsigned Offset) { return insert(Offset, Tail); } - /// insert - Insert the specified RopePiece into this tree node at the /// specified offset. The offset is relative, so "0" is the start of the node. /// @@ -388,18 +390,21 @@ void RopePieceBTreeLeaf::erase(unsigned Offset, unsigned NumBytes) { //===----------------------------------------------------------------------===// namespace { + /// RopePieceBTreeInterior - This represents an interior node in the B+Tree, /// which holds up to 2*WidthFactor pointers to child nodes. class RopePieceBTreeInterior : public RopePieceBTreeNode { /// NumChildren - This holds the number of children currently active in the /// Children array. - unsigned char NumChildren; + unsigned char NumChildren = 0; + RopePieceBTreeNode *Children[2*WidthFactor]; + public: - RopePieceBTreeInterior() : RopePieceBTreeNode(false), NumChildren(0) {} + RopePieceBTreeInterior() : RopePieceBTreeNode(false) {} RopePieceBTreeInterior(RopePieceBTreeNode *LHS, RopePieceBTreeNode *RHS) - : RopePieceBTreeNode(false) { + : RopePieceBTreeNode(false) { Children[0] = LHS; Children[1] = RHS; NumChildren = 2; @@ -414,10 +419,12 @@ namespace { bool isFull() const { return NumChildren == 2*WidthFactor; } unsigned getNumChildren() const { return NumChildren; } + const RopePieceBTreeNode *getChild(unsigned i) const { assert(i < NumChildren && "invalid child #"); return Children[i]; } + RopePieceBTreeNode *getChild(unsigned i) { assert(i < NumChildren && "invalid child #"); return Children[i]; @@ -431,7 +438,6 @@ namespace { Size += getChild(i)->size(); } - /// split - Split the range containing the specified offset so that we are /// guaranteed that there is a place to do an insertion at the specified /// offset. The offset is relative, so "0" is the start of the node. @@ -440,7 +446,6 @@ namespace { /// node is returned and must be inserted into a parent. RopePieceBTreeNode *split(unsigned Offset); - /// insert - Insert the specified ropepiece into this tree node at the /// specified offset. The offset is relative, so "0" is the start of the /// node. @@ -457,11 +462,12 @@ namespace { /// guaranteed that there is a split at Offset. void erase(unsigned Offset, unsigned NumBytes); - static inline bool classof(const RopePieceBTreeNode *N) { + static bool classof(const RopePieceBTreeNode *N) { return !N->isLeaf(); } }; -} // end anonymous namespace + +} // namespace /// split - Split the range containing the specified offset so that we are /// guaranteed that there is a place to do an insertion at the specified @@ -613,7 +619,7 @@ void RopePieceBTreeInterior::erase(unsigned Offset, unsigned NumBytes) { //===----------------------------------------------------------------------===// void RopePieceBTreeNode::Destroy() { - if (RopePieceBTreeLeaf *Leaf = dyn_cast(this)) + if (auto *Leaf = dyn_cast(this)) delete Leaf; else delete cast(this); @@ -627,7 +633,7 @@ void RopePieceBTreeNode::Destroy() { /// node is returned and must be inserted into a parent. RopePieceBTreeNode *RopePieceBTreeNode::split(unsigned Offset) { assert(Offset <= size() && "Invalid offset to split!"); - if (RopePieceBTreeLeaf *Leaf = dyn_cast(this)) + if (auto *Leaf = dyn_cast(this)) return Leaf->split(Offset); return cast(this)->split(Offset); } @@ -641,7 +647,7 @@ RopePieceBTreeNode *RopePieceBTreeNode::split(unsigned Offset) { RopePieceBTreeNode *RopePieceBTreeNode::insert(unsigned Offset, const RopePiece &R) { assert(Offset <= size() && "Invalid offset to insert!"); - if (RopePieceBTreeLeaf *Leaf = dyn_cast(this)) + if (auto *Leaf = dyn_cast(this)) return Leaf->insert(Offset, R); return cast(this)->insert(Offset, R); } @@ -650,12 +656,11 @@ RopePieceBTreeNode *RopePieceBTreeNode::insert(unsigned Offset, /// guaranteed that there is a split at Offset. void RopePieceBTreeNode::erase(unsigned Offset, unsigned NumBytes) { assert(Offset+NumBytes <= size() && "Invalid offset to erase!"); - if (RopePieceBTreeLeaf *Leaf = dyn_cast(this)) + if (auto *Leaf = dyn_cast(this)) return Leaf->erase(Offset, NumBytes); return cast(this)->erase(Offset, NumBytes); } - //===----------------------------------------------------------------------===// // RopePieceBTreeIterator Implementation //===----------------------------------------------------------------------===// @@ -666,10 +671,10 @@ static const RopePieceBTreeLeaf *getCN(const void *P) { // begin iterator. RopePieceBTreeIterator::RopePieceBTreeIterator(const void *n) { - const RopePieceBTreeNode *N = static_cast(n); + const auto *N = static_cast(n); // Walk down the left side of the tree until we get to a leaf. - while (const RopePieceBTreeInterior *IN = dyn_cast(N)) + while (const auto *IN = dyn_cast(N)) N = IN->getChild(0); // We must have at least one leaf. @@ -717,10 +722,12 @@ static RopePieceBTreeNode *getRoot(void *P) { RopePieceBTree::RopePieceBTree() { Root = new RopePieceBTreeLeaf(); } + RopePieceBTree::RopePieceBTree(const RopePieceBTree &RHS) { assert(RHS.empty() && "Can't copy non-empty tree yet"); Root = new RopePieceBTreeLeaf(); } + RopePieceBTree::~RopePieceBTree() { getRoot(Root)->Destroy(); } @@ -730,7 +737,7 @@ unsigned RopePieceBTree::size() const { } void RopePieceBTree::clear() { - if (RopePieceBTreeLeaf *Leaf = dyn_cast(getRoot(Root))) + if (auto *Leaf = dyn_cast(getRoot(Root))) Leaf->clear(); else { getRoot(Root)->Destroy(); @@ -780,8 +787,7 @@ RopePiece RewriteRope::MakeRopeString(const char *Start, const char *End) { // just allocate a new rope piece for it alone. if (Len > AllocChunkSize) { unsigned Size = End-Start+sizeof(RopeRefCountString)-1; - RopeRefCountString *Res = - reinterpret_cast(new char[Size]); + auto *Res = reinterpret_cast(new char[Size]); Res->RefCount = 0; memcpy(Res->Data, Start, End-Start); return RopePiece(Res, 0, End-Start); @@ -791,8 +797,7 @@ RopePiece RewriteRope::MakeRopeString(const char *Start, const char *End) { // Make a new chunk and share it with later allocations. unsigned AllocSize = offsetof(RopeRefCountString, Data) + AllocChunkSize; - RopeRefCountString *Res = - reinterpret_cast(new char[AllocSize]); + auto *Res = reinterpret_cast(new char[AllocSize]); Res->RefCount = 0; memcpy(Res->Data, Start, Len); AllocBuffer = Res; @@ -800,5 +805,3 @@ RopePiece RewriteRope::MakeRopeString(const char *Start, const char *End) { return RopePiece(AllocBuffer, 0, Len); } - - diff --git a/lib/Rewrite/Rewriter.cpp b/lib/Rewrite/Rewriter.cpp index ae41decc64..6041e0c0c3 100644 --- a/lib/Rewrite/Rewriter.cpp +++ b/lib/Rewrite/Rewriter.cpp @@ -1,4 +1,4 @@ -//===--- Rewriter.cpp - Code rewriting interface --------------------------===// +//===- Rewriter.cpp - Code rewriting interface ----------------------------===// // // The LLVM Compiler Infrastructure // @@ -15,11 +15,24 @@ #include "clang/Rewrite/Core/Rewriter.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticIDs.h" +#include "clang/Basic/FileManager.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/Lexer.h" +#include "clang/Rewrite/Core/RewriteBuffer.h" +#include "clang/Rewrite/Core/RewriteRope.h" #include "llvm/ADT/SmallString.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/raw_ostream.h" +#include +#include +#include +#include +#include +#include + using namespace clang; raw_ostream &RewriteBuffer::write(raw_ostream &os) const { @@ -91,7 +104,6 @@ void RewriteBuffer::RemoveText(unsigned OrigOffset, unsigned Size, void RewriteBuffer::InsertText(unsigned OrigOffset, StringRef Str, bool InsertAfter) { - // Nothing to insert, exit early. if (Str.empty()) return; @@ -114,7 +126,6 @@ void RewriteBuffer::ReplaceText(unsigned OrigOffset, unsigned OrigLength, AddReplaceDelta(OrigOffset, NewStr.size() - OrigLength); } - //===----------------------------------------------------------------------===// // Rewriter class //===----------------------------------------------------------------------===// @@ -127,10 +138,8 @@ int Rewriter::getRangeSize(const CharSourceRange &Range, !isRewritable(Range.getEnd())) return -1; FileID StartFileID, EndFileID; - unsigned StartOff, EndOff; - - StartOff = getLocationOffsetAndFileID(Range.getBegin(), StartFileID); - EndOff = getLocationOffsetAndFileID(Range.getEnd(), EndFileID); + unsigned StartOff = getLocationOffsetAndFileID(Range.getBegin(), StartFileID); + unsigned EndOff = getLocationOffsetAndFileID(Range.getEnd(), EndFileID); if (StartFileID != EndFileID) return -1; @@ -145,7 +154,6 @@ int Rewriter::getRangeSize(const CharSourceRange &Range, StartOff = RB.getMappedOffset(StartOff, !opts.IncludeInsertsAtBeginOfRange); } - // Adjust the end offset to the end of the last token, instead of being the // start of the last token if this is a token range. if (Range.isTokenRange()) @@ -158,17 +166,15 @@ int Rewriter::getRangeSize(SourceRange Range, RewriteOptions opts) const { return getRangeSize(CharSourceRange::getTokenRange(Range), opts); } - /// getRewrittenText - Return the rewritten form of the text in the specified /// range. If the start or end of the range was unrewritable or if they are /// in different buffers, this returns an empty string. /// /// Note that this method is not particularly efficient. -/// std::string Rewriter::getRewrittenText(SourceRange Range) const { if (!isRewritable(Range.getBegin()) || !isRewritable(Range.getEnd())) - return ""; + return {}; FileID StartFileID, EndFileID; unsigned StartOff, EndOff; @@ -176,7 +182,7 @@ std::string Rewriter::getRewrittenText(SourceRange Range) const { EndOff = getLocationOffsetAndFileID(Range.getEnd(), EndFileID); if (StartFileID != EndFileID) - return ""; // Start and end in different buffers. + return {}; // Start and end in different buffers. // If edits have been made to this buffer, the delta between the range may // have changed. @@ -212,14 +218,12 @@ std::string Rewriter::getRewrittenText(SourceRange Range) const { unsigned Rewriter::getLocationOffsetAndFileID(SourceLocation Loc, FileID &FID) const { assert(Loc.isValid() && "Invalid location"); - std::pair V = SourceMgr->getDecomposedLoc(Loc); + std::pair V = SourceMgr->getDecomposedLoc(Loc); FID = V.first; return V.second; } - /// getEditBuffer - Get or create a RewriteBuffer for the specified FileID. -/// RewriteBuffer &Rewriter::getEditBuffer(FileID FID) { std::map::iterator I = RewriteBuffers.lower_bound(FID); @@ -393,6 +397,7 @@ bool Rewriter::IncreaseIndentation(CharSourceRange range, } namespace { + // A wrapper for a file stream that atomically overwrites the target. // // Creates a file output stream for a temporary file in the constructor, @@ -403,7 +408,7 @@ class AtomicallyMovedFile { public: AtomicallyMovedFile(DiagnosticsEngine &Diagnostics, StringRef Filename, bool &AllWritten) - : Diagnostics(Diagnostics), Filename(Filename), AllWritten(AllWritten) { + : Diagnostics(Diagnostics), Filename(Filename), AllWritten(AllWritten) { TempFilename = Filename; TempFilename += "-%%%%%%%%"; int FD; @@ -441,7 +446,8 @@ private: std::unique_ptr FileStream; bool &AllWritten; }; -} // end anonymous namespace + +} // namespace bool Rewriter::overwriteChangedFiles() { bool AllWritten = true; diff --git a/lib/Rewrite/TokenRewriter.cpp b/lib/Rewrite/TokenRewriter.cpp index 494defdeda..1f5dec499c 100644 --- a/lib/Rewrite/TokenRewriter.cpp +++ b/lib/Rewrite/TokenRewriter.cpp @@ -1,4 +1,4 @@ -//===--- TokenRewriter.cpp - Token-based code rewriting interface ---------===// +//===- TokenRewriter.cpp - Token-based code rewriting interface -----------===// // // The LLVM Compiler Infrastructure // @@ -16,6 +16,12 @@ #include "clang/Basic/SourceManager.h" #include "clang/Lex/Lexer.h" #include "clang/Lex/ScratchBuffer.h" +#include "clang/Lex/Token.h" +#include +#include +#include +#include + using namespace clang; TokenRewriter::TokenRewriter(FileID FID, SourceManager &SM, @@ -46,9 +52,7 @@ TokenRewriter::TokenRewriter(FileID FID, SourceManager &SM, } } -TokenRewriter::~TokenRewriter() { -} - +TokenRewriter::~TokenRewriter() = default; /// RemapIterator - Convert from token_iterator (a const iterator) to /// TokenRefTy (a non-const iterator). @@ -63,7 +67,6 @@ TokenRewriter::TokenRefTy TokenRewriter::RemapIterator(token_iterator I) { return MapIt->second; } - /// AddToken - Add the specified token into the Rewriter before the other /// position. TokenRewriter::TokenRefTy @@ -77,7 +80,6 @@ TokenRewriter::AddToken(const Token &T, TokenRefTy Where) { return Where; } - TokenRewriter::token_iterator TokenRewriter::AddTokenBefore(token_iterator I, const char *Val) { unsigned Len = strlen(Val); @@ -96,4 +98,3 @@ TokenRewriter::AddTokenBefore(token_iterator I, const char *Val) { return AddToken(Tok, RemapIterator(I)); } - -- 2.40.0