StringRef FileName,
unsigned *Cursor = nullptr);
+/// \brief Returns the replacements corresponding to applying and formatting
+/// \p Replaces.
+tooling::Replacements formatReplacements(StringRef Code,
+ const tooling::Replacements &Replaces,
+ const FormatStyle &Style);
+
+/// \brief In addition to applying all replacements in \p Replaces to \p Code,
+/// this function also reformats the changed code after applying replacements.
+///
+/// \pre Replacements must be for the same file and conflict-free.
+///
+/// Replacement applications happen independently of the success of
+/// other applications.
+///
+/// \returns the changed code with all replacements applied and formatted, if
+/// successful. An empty string otherwise.
+///
+/// See also "include/clang/Tooling/Core/Replacements.h".
+std::string applyAllReplacementsAndFormat(StringRef Code,
+ const tooling::Replacements &Replaces,
+ const FormatStyle &Style);
+
/// \brief Reformats the given \p Ranges in the file \p ID.
///
/// Each range is extended on either end to its next bigger logic unit, i.e.
/// replacements cannot be applied, this returns an empty \c string.
std::string applyAllReplacements(StringRef Code, const Replacements &Replaces);
+/// \brief Calculate the ranges in a single file that are affected by the
+/// Replacements.
+///
+/// \pre Replacements must be for the same file.
+std::vector<tooling::Range>
+calculateChangedRangesInFile(const tooling::Replacements &Replaces);
+
/// \brief Merges two sets of replacements with the second set referring to the
/// code after applying the first set. Within both 'First' and 'Second',
/// replacements must not overlap.
return Replaces;
}
+tooling::Replacements formatReplacements(StringRef Code,
+ const tooling::Replacements &Replaces,
+ const FormatStyle &Style) {
+ if (Replaces.empty())
+ return tooling::Replacements();
+
+ std::string NewCode = applyAllReplacements(Code, Replaces);
+ std::vector<tooling::Range> ChangedRanges =
+ tooling::calculateChangedRangesInFile(Replaces);
+ StringRef FileName = Replaces.begin()->getFilePath();
+ tooling::Replacements FormatReplaces =
+ reformat(Style, NewCode, ChangedRanges, FileName);
+
+ tooling::Replacements MergedReplacements =
+ mergeReplacements(Replaces, FormatReplaces);
+ return MergedReplacements;
+}
+
+std::string applyAllReplacementsAndFormat(StringRef Code,
+ const tooling::Replacements &Replaces,
+ const FormatStyle &Style) {
+ tooling::Replacements NewReplacements =
+ formatReplacements(Code, Replaces, Style);
+ if (NewReplacements.empty())
+ return Code; // Exit early to avoid overhead in `applyAllReplacements`.
+ return applyAllReplacements(Code, NewReplacements);
+}
+
tooling::Replacements reformat(const FormatStyle &Style,
SourceManager &SourceMgr, FileID ID,
ArrayRef<CharSourceRange> Ranges,
//
//===----------------------------------------------------------------------===//
+#include "clang/Tooling/Core/Replacement.h"
+
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticIDs.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h"
#include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/Tooling/Core/Replacement.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_os_ostream.h"
return Result;
}
+std::vector<Range> calculateChangedRangesInFile(const Replacements &Replaces) {
+ std::vector<Range> ChangedRanges;
+ int Shift = 0;
+ for (const Replacement &R : Replaces) {
+ unsigned Offset = R.getOffset() + Shift;
+ unsigned Length = R.getReplacementText().size();
+ Shift += Length - R.getLength();
+ ChangedRanges.push_back(Range(Offset, Length));
+ }
+ return ChangedRanges;
+}
+
namespace {
// Represents a merged replacement, i.e. a replacement consisting of multiple
// overlapping replacements from 'First' and 'Second' in mergeReplacements.
// Merges the next element 'R' into this merged element. As we always merge
// from 'First' into 'Second' or vice versa, the MergedReplacement knows what
- // set the next element is coming from.
+ // set the next element is coming from.
void merge(const Replacement &R) {
if (MergeSecond) {
unsigned REnd = R.getOffset() + Delta + R.getLength();
target_link_libraries(FormatTests
clangFormat
+ clangFrontend
clangToolingCore
)
//
//===----------------------------------------------------------------------===//
-#include "FormatTestUtils.h"
#include "clang/Format/Format.h"
+
+#include "../Tooling/RewriterTestContext.h"
+#include "FormatTestUtils.h"
+
+#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "llvm/Support/Debug.h"
#include "gtest/gtest.h"
verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
}
+class ReplacementTest : public ::testing::Test {
+protected:
+ tooling::Replacement createReplacement(SourceLocation Start, unsigned Length,
+ llvm::StringRef ReplacementText) {
+ return tooling::Replacement(Context.Sources, Start, Length,
+ ReplacementText);
+ }
+
+ RewriterTestContext Context;
+};
+
+TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
+ // Column limit is 20.
+ std::string Code = "Type *a =\n"
+ " new Type();\n"
+ "g(iiiii, 0, jjjjj,\n"
+ " 0, kkkkk, 0, mm);\n"
+ "int bad = format ;";
+ std::string Expected = "auto a = new Type();\n"
+ "g(iiiii, nullptr,\n"
+ " jjjjj, nullptr,\n"
+ " kkkkk, nullptr,\n"
+ " mm);\n"
+ "int bad = format ;";
+ FileID ID = Context.createInMemoryFile("format.cpp", Code);
+ tooling::Replacements Replaces;
+ Replaces.insert(tooling::Replacement(
+ Context.Sources, Context.getLocation(ID, 1, 1), 6, "auto "));
+ Replaces.insert(tooling::Replacement(
+ Context.Sources, Context.getLocation(ID, 3, 10), 1, "nullptr"));
+ Replaces.insert(tooling::Replacement(
+ Context.Sources, Context.getLocation(ID, 4, 3), 1, "nullptr"));
+ Replaces.insert(tooling::Replacement(
+ Context.Sources, Context.getLocation(ID, 4, 13), 1, "nullptr"));
+
+ format::FormatStyle Style = format::getLLVMStyle();
+ Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
+ EXPECT_EQ(Expected, applyAllReplacementsAndFormat(Code, Replaces, Style));
+}
+
} // end namespace
} // end namespace format
} // end namespace clang
EXPECT_FALSE(Range(0, 10).contains(Range(0, 11)));
}
+TEST(Range, CalculateRangesOfReplacements) {
+ // Before: aaaabbbbbbz
+ // After : bbbbbbzzzzzzoooooooooooooooo
+ Replacements Replaces;
+ Replaces.insert(Replacement("foo", 0, 4, ""));
+ Replaces.insert(Replacement("foo", 10, 1, "zzzzzz"));
+ Replaces.insert(Replacement("foo", 11, 0, "oooooooooooooooo"));
+
+ std::vector<Range> Ranges = calculateChangedRangesInFile(Replaces);
+
+ EXPECT_EQ(3ul, Ranges.size());
+ EXPECT_TRUE(Ranges[0].getOffset() == 0);
+ EXPECT_TRUE(Ranges[0].getLength() == 0);
+ EXPECT_TRUE(Ranges[1].getOffset() == 6);
+ EXPECT_TRUE(Ranges[1].getLength() == 6);
+ EXPECT_TRUE(Ranges[2].getOffset() == 12);
+ EXPECT_TRUE(Ranges[2].getLength() == 16);
+}
+
TEST(DeduplicateTest, removesDuplicates) {
std::vector<Replacement> Input;
Input.push_back(Replacement("fileA", 50, 0, " foo "));
projects / clang / commitdiff