Revert "cpp11-migrate: Write header replacements to disk"

This reverts commit 187204. It broke the freebsd bots:

http://lab.llvm.org:8011/builders/clang-X86_64-freebsd/builds/9561

llvm-svn: 187227

Author: espindola

clang-tools-extra/cpp11-migrate/Core/FileOverrides.cpp

@@ -23,39 +23,28 @@
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/system_error.h"
-#include <algorithm>
 
 using namespace clang;
 using namespace clang::tooling;
 
-void HeaderOverride::recordReplacements(
-    llvm::StringRef TransformID, const clang::tooling::Replacements &Replaces) {
-  TransformReplacements TR;
-  TR.TransformID = TransformID;
-  TR.GeneratedReplacements.resize(Replaces.size());
-  std::copy(Replaces.begin(), Replaces.end(), TR.GeneratedReplacements.begin());
-  TransformReplacementsDoc.Replacements.push_back(TR);
-}
-
 SourceOverrides::SourceOverrides(llvm::StringRef MainFileName,
                                  bool TrackChanges)
     : MainFileName(MainFileName), TrackChanges(TrackChanges) {}
 
-void SourceOverrides::applyReplacements(tooling::Replacements &Replaces,
-                                        llvm::StringRef TransformName) {
+void
+SourceOverrides::applyReplacements(clang::tooling::Replacements &Replaces) {
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts(
       new DiagnosticOptions());
   DiagnosticsEngine Diagnostics(
       llvm::IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
       DiagOpts.getPtr());
   FileManager Files((FileSystemOptions()));
   SourceManager SM(Diagnostics, Files);
-  applyReplacements(Replaces, SM, TransformName);
+  applyReplacements(Replaces, SM);
 }
 
-void SourceOverrides::applyReplacements(tooling::Replacements &Replaces,
-                                        SourceManager &SM,
-                                        llvm::StringRef TransformName) {
+void SourceOverrides::applyReplacements(clang::tooling::Replacements &Replaces,
+                                        clang::SourceManager &SM) {
   applyOverrides(SM);
 
   Rewriter Rewrites(SM, LangOptions());
@@ -67,6 +56,12 @@ void SourceOverrides::applyReplacements(tooling::Replacements &Replaces,
   if (!Success)
     llvm::errs() << "error: failed to apply some replacements.";
 
+  applyRewrites(Rewrites);
+  if (TrackChanges)
+    adjustChangedRanges(Replaces);
+}
+
+void SourceOverrides::applyRewrites(Rewriter &Rewrites) {
   std::string ResultBuf;
 
   for (Rewriter::buffer_iterator I = Rewrites.buffer_begin(),
@@ -94,50 +89,36 @@ void SourceOverrides::applyReplacements(tooling::Replacements &Replaces,
     // will be stored as well for later output to disk. Applying replacements
     // in memory will always be necessary as the source goes down the transform
     // pipeline.
+
     HeaderOverride &HeaderOv = Headers[FileName];
+    HeaderOv.FileOverride.swap(ResultBuf);
     // "Create" HeaderOverride if not already existing
-    if (HeaderOv.getFileName().empty())
-      HeaderOv = HeaderOverride(FileName);
-
-    HeaderOv.swapContentOverride(ResultBuf);
+    if (HeaderOv.FileName.empty())
+      HeaderOv.FileName = FileName;
   }
+}
 
-  // Separate replacements to header files
+void SourceOverrides::adjustChangedRanges(const Replacements &Replaces) {
+  // Start by grouping replacements by file name
   Replacements MainFileReplaces;
-  ReplacementsMap HeadersReplaces;
-  for (Replacements::const_iterator I = Replaces.begin(), E = Replaces.end();
-      I != E; ++I) {
+  llvm::StringMap<Replacements> HeadersReplaces;
+
+  for (Replacements::iterator I = Replaces.begin(), E = Replaces.end(); I != E;
+       ++I) {
     llvm::StringRef ReplacementFileName = I->getFilePath();
 
-    if (ReplacementFileName == MainFileName) {
+    if (ReplacementFileName == MainFileName)
       MainFileReplaces.insert(*I);
-      continue;
-    }
-
-    HeadersReplaces[ReplacementFileName].insert(*I);
+    else
+      HeadersReplaces[ReplacementFileName].insert(*I);
   }
 
-  // Record all replacements to headers.
-  for (ReplacementsMap::const_iterator I = HeadersReplaces.begin(),
-                                       E = HeadersReplaces.end();
-       I != E; ++I) {
-    HeaderOverride &HeaderOv = Headers[I->getKey()];
-    HeaderOv.recordReplacements(TransformName, I->getValue());
-  }
-
-  if (TrackChanges)
-    adjustChangedRanges(MainFileReplaces, HeadersReplaces);
-}
-
-void
-SourceOverrides::adjustChangedRanges(const Replacements &MainFileReplaces,
-                                     const ReplacementsMap &HeadersReplaces) {
-  // Adjust the changed ranges for each individual file
-  MainFileChanges.adjustChangedRanges(MainFileReplaces);
-  for (ReplacementsMap::const_iterator I = HeadersReplaces.begin(),
-                                       E = HeadersReplaces.end();
+  // Then adjust the changed ranges for each individual file
+  MainFileChanges.adjustChangedRanges(Replaces);
+  for (llvm::StringMap<Replacements>::iterator I = HeadersReplaces.begin(),
+                                               E = HeadersReplaces.end();
        I != E; ++I) {
-    Headers[I->getKey()].adjustChangedRanges(I->getValue());
+    Headers[I->getKey()].Changes.adjustChangedRanges(I->getValue());
   }
 }
 
@@ -150,11 +131,11 @@ void SourceOverrides::applyOverrides(SourceManager &SM) const {
 
   for (HeaderOverrides::const_iterator I = Headers.begin(), E = Headers.end();
        I != E; ++I) {
-    assert(!I->second.getContentOverride().empty() &&
+    assert(!I->second.FileOverride.empty() &&
            "Header override should not be empty!");
     SM.overrideFileContents(
-        FM.getFile(I->second.getFileName()),
-        llvm::MemoryBuffer::getMemBuffer(I->second.getContentOverride()));
+        FM.getFile(I->second.FileName),
+        llvm::MemoryBuffer::getMemBuffer(I->second.FileOverride));
   }
 }
 

clang-tools-extra/cpp11-migrate/Core/FileOverrides.h

@@ -16,7 +16,6 @@
 #ifndef CPP11_MIGRATE_FILE_OVERRIDES_H
 #define CPP11_MIGRATE_FILE_OVERRIDES_H
 
-#include "Core/ReplacementsYaml.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/StringMap.h"
 
@@ -59,52 +58,13 @@ class ChangedRanges {
 };
 
 /// \brief Container for storing override information for a single headers.
-class HeaderOverride {
-public:
-  /// \brief Constructors.
-  /// @{
+struct HeaderOverride {
   HeaderOverride() {}
-  HeaderOverride(llvm::StringRef FileName) {
-    TransformReplacementsDoc.FileName = FileName;
-  }
-  /// @}
-
-  /// \brief Getter for FileName.
-  llvm::StringRef getFileName() const {
-    return TransformReplacementsDoc.FileName;
-  }
-
-  /// \brief Accessor for ContentOverride.
-  /// @{
-  llvm::StringRef getContentOverride() const { return ContentOverride; }
-  void setContentOverride(const llvm::StringRef S) { ContentOverride = S; }
-  /// @}
-
-  /// \brief Getter for Changes.
-  const ChangedRanges &getChanges() const { return Changes; }
+  HeaderOverride(llvm::StringRef FileName) : FileName(FileName) {}
 
-  /// \brief Swaps the content of ContentOverride with \param S
-  void swapContentOverride(std::string &S) { ContentOverride.swap(S); }
-
-  /// \brief Getter for TransformReplacementsDoc.
-  const TransformDocument &getTransformReplacementsDoc() const {
-    return TransformReplacementsDoc;
-  }
-
-  /// \brief Stores the replacements made by a transform to the header this
-  /// object represents.
-  void recordReplacements(llvm::StringRef TransformID,
-                          const clang::tooling::Replacements &Replaces);
-
-  /// \brief Helper function to adjust the changed ranges.
-  void adjustChangedRanges(const clang::tooling::Replacements &Replaces) {
-    Changes.adjustChangedRanges(Replaces);
-  }
-
-private:
-  std::string ContentOverride;
+  std::string FileName;
+  std::string FileOverride;
   ChangedRanges Changes;
-  TransformDocument TransformReplacementsDoc;
 };
 
 /// \brief Container mapping header file names to override information.
@@ -140,10 +100,8 @@ class SourceOverrides {
   /// \param Replaces The replacements to apply.
   /// \param SM A user provided SourceManager to be used when applying rewrites.
   void applyReplacements(clang::tooling::Replacements &Replaces,
-                         clang::SourceManager &SM,
-                         llvm::StringRef TransformName);
-  void applyReplacements(clang::tooling::Replacements &Replaces,
-                         llvm::StringRef TransformName);
+                         clang::SourceManager &SM);
+  void applyReplacements(clang::tooling::Replacements &Replaces);
 
   /// \brief Convenience function for applying this source's overrides to
   /// the given SourceManager.
@@ -160,16 +118,13 @@ class SourceOverrides {
   /// @}
 
 private:
-  typedef llvm::StringMap<clang::tooling::Replacements> ReplacementsMap;
-
   /// \brief Flatten the Rewriter buffers of \p Rewrite and store results as
   /// file content overrides.
   void applyRewrites(clang::Rewriter &Rewrite);
 
   /// \brief Adjust the changed ranges to reflect the parts of the files that
   /// have been replaced.
-  void adjustChangedRanges(const clang::tooling::Replacements &Replaces,
-                           const ReplacementsMap &HeadersReplaces);
+  void adjustChangedRanges(const clang::tooling::Replacements &Replaces);
 
   const std::string MainFileName;
   std::string MainFileOverride;

clang-tools-extra/cpp11-migrate/Core/Reformatting.cpp

@@ -47,10 +47,10 @@ void Reformatter::reformatChanges(SourceOverrides &Overrides,
        I != E; ++I) {
     const HeaderOverride &Header = I->getValue();
     const tooling::Replacements &HeaderReplaces =
-        reformatSingleFile(Header.getFileName(), Header.getChanges(), SM);
+        reformatSingleFile(Header.FileName, Header.Changes, SM);
     Replaces.insert(HeaderReplaces.begin(), HeaderReplaces.end());
   }
-  Overrides.applyReplacements(Replaces, SM, "reformatter");
+  Overrides.applyReplacements(Replaces, SM);
 }
 
 tooling::Replacements Reformatter::reformatSingleFile(

clang-tools-extra/cpp11-migrate/Core/ReplacementsYaml.h

@@ -117,7 +117,7 @@ bool Transform::handleBeginSource(CompilerInstance &CI, StringRef Filename) {
 void Transform::handleEndSource() {
   if (!getReplacements().empty()) {
     SourceOverrides &SO = Overrides->getOrCreate(CurrentSource);
-    SO.applyReplacements(getReplacements(), getName());
+    SO.applyReplacements(getReplacements());
   }
 
   if (Options().EnableTiming)