Added formatAndApplyAllReplacements that works on multiple files in libTooling.

[ioeric]

Summary

formatAndApplyAllReplacements takes a set of Replacements, applies them on a
Rewriter, and reformats the changed code.

[djasper]

include/clang/Tooling/Core/Replacement.h

237 ↗

(On Diff #49740)

Hm... I am not sure here. I think I would implement this entirely without FileManager or FileEntries, just based on the names of the file. I guess you are worried about different paths leading to the same FileEntry?

include/clang/Tooling/ReplacementsFormat.h

1 ↗

(On Diff #49740)

I think this can happily live in Refactoring.h/cpp for now.

40 ↗

(On Diff #49740)

This is probably a pre-existing issue in formatReplacements, but I think conceptually it might be wrong to hand in the Style. I think it might be a better idea to use clang::format::getStyle() with the filename stored inside of the replacement to get the style that should actually be used for any given change. Not sure whether we'd also want the capability to overwrite this. Manuel, what do you think?

[ioeric]

• Moved formatAndApplyAllReplacements to Tooling/Refactoing; added an overloaded version of formatAndApplyAllReplacements that takes no Style; groupReplacementsByFile groups Replacements by filename instead of FileEntry.

include/clang/Tooling/Core/Replacement.h

237 ↗

(On Diff #49740)

You are right. Getting rid of FileManger would make more sense for users. And yes, I was worrying about different names leading to the same entry. Do we need to worry about this case? Or we can assume Replacements for the same file always have the same file path?

[ioeric]

• removed unused forward declarations.

[djasper]

include/clang/Tooling/Core/Replacement.h

228 ↗

(On Diff #49807)

This was pre-existing, but I'd remove the "InFile" suffix. It doesn't seem to add any information.

230 ↗

(On Diff #49807)

I think the key type in a map is always const, so no need for "const".

235 ↗

(On Diff #49807)

I also wonder whether this should really return a map. I find such maps in interfaces sometimes a bit difficult as they have some cost and the subsequent analyses might actually prefer a different container. How about instead just returning a vector<Replacements>? I mean the Replacements themselves already have the filename stored in them so the key in the map is redundant anyway.

Manuel, any thoughts?

[ioeric]

include/clang/Tooling/Core/Replacement.h

228 ↗

(On Diff #49807)

Will remove the "InFile" suffix.

230 ↗

(On Diff #49807)

I think "const" is needed since the Entry passed to map's [] operator is of type const FileEntry * in FileToReplaces[Entry].push_back(Replace). The code didn't compile without the "const" qualifier.

235 ↗

(On Diff #49807)

But I think the tradeoff of using vector<Replacements> is the insertion time since we'd need to index Replcements with the same filename for each insertion. Or maybe we can have a map from filename to vector index as a local variable and return a vector<Replacements>?

[djasper]

include/clang/Tooling/Core/Replacement.h

230 ↗

(On Diff #49807)

Well, now it's a string and the strings are copied anyway. I am pretty sure it will compile after removing "const".

235 ↗

(On Diff #49807)

Yes, that is what I would probably do, have a local map and return a vector to keep the interface cleaner. But lets see what Manuel thinks.

[ioeric]

include/clang/Tooling/Core/Replacement.h

230 ↗

(On Diff #49807)

Ooops! I was on another git branch! Yes, it definitely compiles for string. Sorry about that.

[cfe-commits]

Friendly PING.

@klimek
Hi Manuel, what do you think about the return type for
groupReplacementsByFile?
Daniel suggests that instead of "std::map<std::string, Replacements>", it
returns "std::vector<Replacements>".

• msg-26182-27.txt159 BDownload

[klimek]

include/clang/Tooling/Core/Replacement.h

237 ↗

(On Diff #49740)

I like a map-based interface slightly better here, mainly because I think it's a bit harder to write buggy code against it, it's less work if the user wants to apply some kind of sharding (threads can just hand around the vectors without the need to loop over the vector yet again to split it, or hand indices around), and (to me at least) it is slightly easier to grasp the function's contract.

Regarding the FileEntries, I'm not overly worried about file entries leading to the same file (I believe this is not too hard to handle one level higher if necessary), and the interface would seem significantly simpler without the FileManager.

include/clang/Tooling/ReplacementsFormat.h

40 ↗

(On Diff #49740)

(not sure whether that's still unresolved, as I think I talked about this with Eric already)
I believe that is what style=file is for, right? I'm fine with a convenience method with style=file, but it seems like the generic one makes sense to have, too.

[ioeric]

• renamed calculateChangedRangesInFile to calculateChangedRanges; removed const from FileToReplacementsMap key type.

[ioeric]

PING

[klimek]

include/clang/Tooling/Core/Replacement.h

231 ↗

(On Diff #50627)

Honestly, I'd get rid of the typedef. Daniel, what do you think?

lib/Tooling/Refactoring.cpp

90 ↗

(On Diff #50627)

Just call the above with the format::getStyle("file", FilePath, "LLVM")?
(note that I think "Google" is a bad default style here)

unittests/Tooling/RefactoringTest.cpp

206 ↗

(On Diff #50627)

Also use a ColumnLimit to make the test more readable?

[ioeric]

lib/Tooling/Refactoring.cpp

90 ↗

(On Diff #50627)

But there could be more than one FilePath in Replaces?

unittests/Tooling/RefactoringTest.cpp

206 ↗

(On Diff #50627)

We don't have access to the Style here? Any way to set ColumnLimit?

[djasper]

include/clang/Tooling/Core/Replacement.h

231 ↗

(On Diff #50627)

I agree. I don't think it carries its weight and actually makes the code harder to read. Plus all users can probably use auto :-).

[klimek]

lib/Tooling/Refactoring.cpp

90 ↗

(On Diff #50627)

Ah, right; In that case, we have 2 options:

1. hand in a callback FormatStyle(StringRef), so users can hand in format::getStyle if needed; adapt the fixed-style one to call the callback-based one with a callback that just returns the fixed style
2. refactor so the inner loop becomes trivial, something like this: for (auto &ReplacementsByFile : groupReplacementsByFile(Replaces)) { Style = ... Result = applyAllReplacements(formatReplacements(getCode(ReplacementsByFile.first, ReplacementsByFile.second, Style))) && Result; } return Result;

[ioeric]

• removed FileToReplacementsMap typedef; refactored formatAndApplyReplacements to reduce duplicated code.

lib/Tooling/Refactoring.cpp

90 ↗

(On Diff #50627)

Adding a helper function seems to do the trick too.

[klimek]

unittests/Tooling/RefactoringTest.cpp

206 ↗

(On Diff #51166)

I'd rely on the general case to be covered by the other test then, and just test that the style is picked up correctly (or falls back correctly to LLVM style).

[ioeric]

unittests/Tooling/RefactoringTest.cpp

206 ↗

(On Diff #51166)

You are right. Shall I remove this test case for now and add general test cases(I mean non-unit test) for format::getStyle in the future?

[cfe-commits]

Just wanted to check if there are existing test cases for format::getStyle.
If there is no test for it, I'll add test cases for sure :=)

• msg-9784-23.txt159 BDownload

[ioeric]

• removed format::getStyle test case from ToolingTests;

[ioeric]

@Daniel, now that Manuel is on vacation. Could you have a look at the patch?

unittests/Tooling/RefactoringTest.cpp

206 ↗

(On Diff #51433)

The test case for format::getStyle has been moved to another patch.

[djasper]

include/clang/Tooling/Refactoring.h

91 ↗

(On Diff #51433)

Do you have a use case where we'd want to call this with a fixed style? Otherwise, I'd just remove this function for now.

93 ↗

(On Diff #51433)

Don't copy the comment for the function. It is bound to go out of sync and makes users wonder what the actual differences are. Put this function first and replace "Instead of .." with "This function use the filename stored in the replacements to determine the appropriate style.".

Then in the comment to the other just write: "/// Same as above but use fixed style \p Style."

[ioeric]

include/clang/Tooling/Refactoring.h

91 ↗

(On Diff #51433)

If the .clang-format doesn't exist, it can only fall back to one default style, which is LLVM now. Shouldn't users have the flexibility to specify other styles if there is no .clang-format file?

[djasper]

include/clang/Tooling/Refactoring.h

91 ↗

(On Diff #51433)

I am not sure, but I usually like to keep interfaces small until we have actual use cases. It is very hard to foresee in what ways this can possibly be used. An alternative might be to hand in the style as a string which is similar to what clang-format takes on the command line. Then people can supply "file", "Google", ... and we can hand that to getStyle().

[ioeric]

• Change the Style parameter of formatAndApplyReplacements from FormatStyle to be a Style name string.

[djasper]

Looks good.

include/clang/Tooling/Refactoring.h

93 ↗

(On Diff #51933)

See also for what? Maybe just remove?

95 ↗

(On Diff #51933)

Maybe Style should default to "file".

[ioeric]

• Minor changes.

cfe/trunk/include/clang/Basic/SourceManager.h

public:
   FileID createFileID(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                       SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
                       int LoadedID = 0, unsigned LoadedOffset = 0,
                       SourceLocation IncludeLoc = SourceLocation()) {
     return createFileID(createMemBufferContentCache(std::move(Buffer)),
                         IncludeLoc, FileCharacter, LoadedID, LoadedOffset);
   }
 
+  /// \brief Get the FileID for \p SourceFile if it exists. Otherwise, create a
+  /// new FileID for the \p SourceFile.
+  FileID getOrCreateFileID(const FileEntry *SourceFile,
+                           SrcMgr::CharacteristicKind FileCharacter) {
+    FileID ID = translateFile(SourceFile);
+    return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(),
+                                            FileCharacter);
+  }
+
   /// \brief Return a new SourceLocation that encodes the
   /// fact that a token from SpellingLoc should actually be referenced from
   /// ExpansionLoc, and that it represents the expansion of a macro argument
   /// into the function-like macro body.
   SourceLocation createMacroArgExpansionLoc(SourceLocation Loc,
                                             SourceLocation ExpansionLoc,
                                             unsigned TokLength);
 

cfe/trunk/include/clang/Format/Format.h

tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
                                    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.
 /// everything that might influence its formatting or might be influenced by its
 /// formatting.
 ///
 /// Returns the ``Replacements`` necessary to make all \p Ranges comply with
 /// \p Style.

cfe/trunk/include/clang/Tooling/Core/Replacement.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_CORE_REPLACEMENT_H
 #define LLVM_CLANG_TOOLING_CORE_REPLACEMENT_H
 
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/StringRef.h"
+#include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 
 class Rewriter;
 
bool applyAllReplacements(const std::vector<Replacement> &Replaces,
                           Rewriter &Rewrite);
 
 /// \brief Applies all replacements in \p Replaces to \p Code.
 ///
 /// This completely ignores the path stored in each replacement. If one or more
 /// 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
+/// \brief Calculates 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);
+std::vector<Range> calculateChangedRanges(const Replacements &Replaces);
+
+/// \brief Groups a random set of replacements by file path. Replacements
+/// related to the same file entry are put into the same vector.
+std::map<std::string, Replacements>
+groupReplacementsByFile(const 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.
 Replacements mergeReplacements(const Replacements &First,
                                const Replacements &Second);
 
 template <typename Node>

cfe/trunk/include/clang/Tooling/Refactoring.h

 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Tooling.h"
 #include <string>
 
 namespace clang {
 
 class Rewriter;
 
+namespace format {
+
+class FormatStyle;
+
+} // namespace format
+
 namespace tooling {
 
 /// \brief A tool to run refactorings.
 ///
 /// This is a refactoring specific version of \see ClangTool. FrontendActions
 /// passed to run() and runAndSave() should add replacements to
 /// getReplacements().
 class RefactoringTool : public ClangTool {

 private:
   /// \brief Write all refactored files to disk.
   int saveRewrittenFiles(Rewriter &Rewrite);
 
 private:
   Replacements Replace;
 };
 
+/// \brief Groups \p Replaces by the file path and applies each group of
+/// Replacements on the related file in \p Rewriter. In addition to applying
+/// given Replacements, this function also formats the changed code.
+///
+/// \pre Replacements must be conflict-free.
+///
+/// Replacement applications happen independently of the success of other
+/// applications.
+///
+/// \param[in] Replaces Replacements to apply.
+/// \param[in] Rewrite The `Rewritter` to apply replacements on.
+/// \param[in] Style The style name used for reformatting. See ```getStyle``` in
+/// "include/clang/Format/Format.h" for all possible style forms.
+///
+/// \returns true if all replacements applied and formatted. false otherwise.
+bool formatAndApplyAllReplacements(const Replacements &Replaces,
+                                   Rewriter &Rewrite, StringRef Style = "file");
+
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTORING_H

cfe/trunk/lib/Format/Format.cpp

 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);
+      tooling::calculateChangedRanges(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,
                                bool *IncompleteFormat) {
   FormatStyle Expanded = expandPresets(Style);
   if (Expanded.DisableFormat)
     return tooling::Replacements();
   Formatter formatter(Expanded, SourceMgr, ID, Ranges);

cfe/trunk/lib/Tooling/CMakeLists.txt

add_clang_library(clangTooling
   RefactoringCallbacks.cpp
   Tooling.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangDriver
+  clangFormat
   clangFrontend
   clangLex
   clangRewrite
   clangToolingCore
   )

cfe/trunk/lib/Tooling/Core/Replacement.cpp

bool Replacement::isApplicable() const {
   return FilePath != InvalidLocation;
 }
 
 bool Replacement::apply(Rewriter &Rewrite) const {
   SourceManager &SM = Rewrite.getSourceMgr();
   const FileEntry *Entry = SM.getFileManager().getFile(FilePath);
   if (!Entry)
     return false;
-  FileID ID;
-  // FIXME: Use SM.translateFile directly.
-  SourceLocation Location = SM.translateFileLineCol(Entry, 1, 1);
-  ID = Location.isValid() ?
-    SM.getFileID(Location) :
-    SM.createFileID(Entry, SourceLocation(), SrcMgr::C_User);
-  // FIXME: We cannot check whether Offset + Length is in the file, as
-  // the remapping API is not public in the RewriteBuffer.
+
+  FileID ID = SM.getOrCreateFileID(Entry, SrcMgr::C_User);
   const SourceLocation Start =
     SM.getLocForStartOfFile(ID).
     getLocWithOffset(ReplacementRange.getOffset());
   // ReplaceText returns false on success.
   // ReplaceText only fails if the source location is not a file location, in
   // which case we already returned false earlier.
   bool RewriteSucceeded = !Rewrite.ReplaceText(
       Start, ReplacementRange.getLength(), ReplacementText);
for (std::vector<Replacement>::const_iterator I = Replaces.begin(),
     } else {
       Result = false;
     }
   }
   return Result;
 }
 
 std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) {
+  if (Replaces.empty()) return Code;
+
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
       new DiagnosticOptions);
   SourceManager SourceMgr(Diagnostics, Files);
   Rewriter Rewrite(SourceMgr, LangOptions());
std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) {
   }
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   Rewrite.getEditBuffer(ID).write(OS);
   OS.flush();
   return Result;
 }
 
-std::vector<Range> calculateChangedRangesInFile(const Replacements &Replaces) {
+std::vector<Range> calculateChangedRanges(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));
   }
private:
   // as the element is only extended to the right.
   const StringRef FilePath;
   const unsigned Offset;
   unsigned Length;
   std::string Text;
 };
 } // namespace
 
+std::map<std::string, Replacements>
+groupReplacementsByFile(const Replacements &Replaces) {
+  std::map<std::string, Replacements> FileToReplaces;
+  for (const auto &Replace : Replaces) {
+    FileToReplaces[Replace.getFilePath()].insert(Replace);
+  }
+  return FileToReplaces;
+}
+
 Replacements mergeReplacements(const Replacements &First,
                                const Replacements &Second) {
   if (First.empty() || Second.empty())
     return First.empty() ? Second : First;
 
   // Delta is the amount of characters that replacements from 'Second' need to
   // be shifted so that their offsets refer to the original text.
   int Delta = 0;

cfe/trunk/lib/Tooling/Refactoring.cpp

 //===--- Refactoring.cpp - Framework for clang refactoring tools ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Implements tools to support refactorings.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Format/Format.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_os_ostream.h"
 

 bool RefactoringTool::applyAllReplacements(Rewriter &Rewrite) {
   return tooling::applyAllReplacements(Replace, Rewrite);
 }
 
 int RefactoringTool::saveRewrittenFiles(Rewriter &Rewrite) {
   return Rewrite.overwriteChangedFiles() ? 1 : 0;
 }
 
+bool formatAndApplyAllReplacements(const Replacements &Replaces,
+                                   Rewriter &Rewrite, StringRef Style) {
+  SourceManager &SM = Rewrite.getSourceMgr();
+  FileManager &Files = SM.getFileManager();
+
+  auto FileToReplaces = groupReplacementsByFile(Replaces);
+
+  bool Result = true;
+  for (auto &FileAndReplaces : FileToReplaces) {
+    const std::string FilePath = FileAndReplaces.first;
+    auto &CurReplaces = FileAndReplaces.second;
+
+    const FileEntry *Entry = Files.getFile(FilePath);
+    FileID ID = SM.getOrCreateFileID(Entry, SrcMgr::C_User);
+    StringRef Code = SM.getBufferData(ID);
+
+    format::FormatStyle CurStyle = format::getStyle(Style, FilePath, "LLVM");
+    Replacements NewReplacements =
+        format::formatReplacements(Code, CurReplaces, CurStyle);
+    Result = applyAllReplacements(NewReplacements, Rewrite) && Result;
+  }
+  return Result;
+}
+
 } // end namespace tooling
 } // end namespace clang

cfe/trunk/unittests/Format/FormatTest.cpp

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));
+  EXPECT_EQ(Expected, applyAllReplacements(
+                          Code, formatReplacements(Code, Replaces, Style)));
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang

cfe/trunk/unittests/Tooling/CMakeLists.txt

add_clang_unittest(ToolingTests
   ReplacementsYamlTest.cpp
   QualTypeNamesTest.cpp
   )
 
 target_link_libraries(ToolingTests
   clangAST
   clangASTMatchers
   clangBasic
+  clangFormat
   clangFrontend
   clangLex
   clangRewrite
   clangTooling
   clangToolingCore
   )

cfe/trunk/unittests/Tooling/RefactoringTest.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
Replaces.insert(Replacement(Context.Sources, SourceLocation(),
                               5, "2"));
   Replaces.insert(Replacement(Context.Sources, Context.getLocation(IDz, 1, 1),
                               4, "z"));
   EXPECT_FALSE(applyAllReplacements(Replaces, Context.Rewrite));
   EXPECT_EQ("a", Context.getRewrittenText(IDa));
   EXPECT_EQ("z", Context.getRewrittenText(IDz));
 }
 
+TEST_F(ReplacementTest, MultipleFilesReplaceAndFormat) {
+  // Column limit is 20.
+  std::string Code1 = "Long *a =\n"
+                      "    new Long();\n"
+                      "long x = 1;";
+  std::string Expected1 = "auto a = new Long();\n"
+                          "long x =\n"
+                          "    12345678901;";
+  std::string Code2 = "int x = 123;\n"
+                      "int y = 0;";
+  std::string Expected2 = "int x =\n"
+                          "    1234567890123;\n"
+                          "int y = 10;";
+  FileID ID1 = Context.createInMemoryFile("format_1.cpp", Code1);
+  FileID ID2 = Context.createInMemoryFile("format_2.cpp", Code2);
+
+  tooling::Replacements Replaces;
+  // Scrambled the order of replacements.
+  Replaces.insert(tooling::Replacement(
+      Context.Sources, Context.getLocation(ID2, 1, 12), 0, "4567890123"));
+  Replaces.insert(tooling::Replacement(
+      Context.Sources, Context.getLocation(ID1, 1, 1), 6, "auto "));
+  Replaces.insert(tooling::Replacement(
+      Context.Sources, Context.getLocation(ID2, 2, 9), 1, "10"));
+  Replaces.insert(tooling::Replacement(
+      Context.Sources, Context.getLocation(ID1, 3, 10), 1, "12345678901"));
+
+  EXPECT_TRUE(formatAndApplyAllReplacements(
+      Replaces, Context.Rewrite, "{BasedOnStyle: LLVM, ColumnLimit: 20}"));
+  EXPECT_EQ(Expected1, Context.getRewrittenText(ID1));
+  EXPECT_EQ(Expected2, Context.getRewrittenText(ID2));
+}
+
 TEST(ShiftedCodePositionTest, FindsNewCodePosition) {
   Replacements Replaces;
   Replaces.insert(Replacement("", 0, 1, ""));
   Replaces.insert(Replacement("", 4, 3, " "));
   // Assume ' int   i;' is turned into 'int i;' and cursor is located at '|'.
   EXPECT_EQ(0u, shiftedCodePosition(Replaces, 0)); // |int   i;
   EXPECT_EQ(0u, shiftedCodePosition(Replaces, 1)); //  |nt   i;
   EXPECT_EQ(1u, shiftedCodePosition(Replaces, 2)); //  i|t   i;

 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);
+  std::vector<Range> Ranges = calculateChangedRanges(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);