Index: include/clang/Tooling/Core/Diagnostics.h

===================================================================

--- include/clang/Tooling/Core/Diagnostics.h	(revision 278390)

+++ include/clang/Tooling/Core/Diagnostics.h	(working copy)

@@ -1,254 +1,54 @@

-//===--- Replacement.h - Framework for clang refactoring tools --*- C++ -*-===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-//

-//  Classes supporting refactorings that span multiple translation units.

-//  While single translation unit refactorings are supported via the Rewriter,

-//  when refactoring multiple translation units changes must be stored in a

-//  SourceManager independent form, duplicate changes need to be removed, and

-//  all changes must be applied at once at the end of the refactoring so that

-//  the code is always parseable.

-//

-//===----------------------------------------------------------------------===//

-

-#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 "llvm/Support/Error.h"

-#include <map>

-#include <set>

+#ifndef LLVM_CLANG_TOOLING_CORE_DIAGNOSTICS_H

+#define LLVM_CLANG_TOOLING_CORE_DIAGNOSTICS_H

+#include "clang/Basic/Diagnostic.h"

+#include "llvm/ADT/SmallVector.h"

+#include "Replacement.h"

 #include <string>

-#include <vector>

-

 namespace clang {

+    namespace tooling {

-class Rewriter;

+        struct DiagnosticsMessage {

+            DiagnosticsMessage(StringRef Message = "");

+            DiagnosticsMessage(StringRef Message, const SourceManager &Sources,

+                    SourceLocation Loc);

+            std::string Message;

+            std::string FilePath;

+            unsigned FileOffset;

+        };

-namespace tooling {

+        struct Diagnostics {

-/// \brief A source range independent of the \c SourceManager.

-class Range {

-public:

-  Range() : Offset(0), Length(0) {}

-  Range(unsigned Offset, unsigned Length) : Offset(Offset), Length(Length) {}

+            enum Level {

+                Warning = DiagnosticsEngine::Warning,

+                Error = DiagnosticsEngine::Error

+            };

-  /// \brief Accessors.

-  /// @{

-  unsigned getOffset() const { return Offset; }

-  unsigned getLength() const { return Length; }

-  /// @}

+            Diagnostics();

+            Diagnostics(StringRef CheckName, Level DiagLevel, bool IsWarningAsError,

+                    StringRef BuildDirectory);

+            std::string CheckName;

+            DiagnosticsMessage Message;

+            tooling::Replacements Fix;

+            SmallVector<DiagnosticsMessage, 1> Notes;

-  /// \name Range Predicates

-  /// @{

-  /// \brief Whether this range overlaps with \p RHS or not.

-  bool overlapsWith(Range RHS) const {

-    return Offset + Length > RHS.Offset && Offset < RHS.Offset + RHS.Length;

-  }

+            // A build directory of the diagnostic source file.

+            //

+            // It's an absolute path which is `directory` field of the source file in

+            // compilation database. If users don't specify the compilation database

+            // directory, it is the current directory where clang-tidy runs.

+            //

+            // Note: it is empty in unittest.

+            std::string BuildDirectory;

-  /// \brief Whether this range contains \p RHS or not.

-  bool contains(Range RHS) const {

-    return RHS.Offset >= Offset &&

-           (RHS.Offset + RHS.Length) <= (Offset + Length);

-  }

+            Level DiagLevel;

+            bool IsWarningAsError;

+        };

-  /// \brief Whether this range equals to \p RHS or not.

-  bool operator==(const Range &RHS) const {

-    return Offset == RHS.getOffset() && Length == RHS.getLength();

-  }

-  /// @}

-

-private:

-  unsigned Offset;

-  unsigned Length;

-};

-

-/// \brief A text replacement.

-///

-/// Represents a SourceManager independent replacement of a range of text in a

-/// specific file.

-class Replacement {

-public:

-  /// \brief Creates an invalid (not applicable) replacement.

-  Replacement();

-

-  /// \brief Creates a replacement of the range [Offset, Offset+Length) in

-  /// FilePath with ReplacementText.

-  ///

-  /// \param FilePath A source file accessible via a SourceManager.

-  /// \param Offset The byte offset of the start of the range in the file.

-  /// \param Length The length of the range in bytes.

-  Replacement(StringRef FilePath, unsigned Offset, unsigned Length,

-              StringRef ReplacementText);

-

-  /// \brief Creates a Replacement of the range [Start, Start+Length) with

-  /// ReplacementText.

-  Replacement(const SourceManager &Sources, SourceLocation Start,

-              unsigned Length, StringRef ReplacementText);

-

-  /// \brief Creates a Replacement of the given range with ReplacementText.

-  Replacement(const SourceManager &Sources, const CharSourceRange &Range,

-              StringRef ReplacementText,

-              const LangOptions &LangOpts = LangOptions());

-

-  /// \brief Creates a Replacement of the node with ReplacementText.

-  template <typename Node>

-  Replacement(const SourceManager &Sources, const Node &NodeToReplace,

-              StringRef ReplacementText,

-              const LangOptions &LangOpts = LangOptions());

-

-  /// \brief Returns whether this replacement can be applied to a file.

-  ///

-  /// Only replacements that are in a valid file can be applied.

-  bool isApplicable() const;

-

-  /// \brief Accessors.

-  /// @{

-  StringRef getFilePath() const { return FilePath; }

-  unsigned getOffset() const { return ReplacementRange.getOffset(); }

-  unsigned getLength() const { return ReplacementRange.getLength(); }

-  StringRef getReplacementText() const { return ReplacementText; }

-  /// @}

-

-  /// \brief Applies the replacement on the Rewriter.

-  bool apply(Rewriter &Rewrite) const;

-

-  /// \brief Returns a human readable string representation.

-  std::string toString() const;

-

- private:

-   void setFromSourceLocation(const SourceManager &Sources,

-                              SourceLocation Start, unsigned Length,

-                              StringRef ReplacementText);

-   void setFromSourceRange(const SourceManager &Sources,

-                           const CharSourceRange &Range,

-                           StringRef ReplacementText,

-                           const LangOptions &LangOpts);

-

-  std::string FilePath;

-  Range ReplacementRange;

-  std::string ReplacementText;

-};

-

-/// \brief Less-than operator between two Replacements.

-bool operator<(const Replacement &LHS, const Replacement &RHS);

-

-/// \brief Equal-to operator between two Replacements.

-bool operator==(const Replacement &LHS, const Replacement &RHS);

-

-/// \brief A set of Replacements.

-/// FIXME: Change to a vector and deduplicate in the RefactoringTool.

-typedef std::set<Replacement> Replacements;

-

-/// \brief Apply all replacements in \p Replaces to the Rewriter \p Rewrite.

-///

-/// Replacement applications happen independently of the success of

-/// other applications.

-///

-/// \returns true if all replacements apply. false otherwise.

-bool applyAllReplacements(const Replacements &Replaces, Rewriter &Rewrite);

-

-/// \brief Apply all replacements in \p Replaces to the Rewriter \p Rewrite.

-///

-/// Replacement applications happen independently of the success of

-/// other applications.

-///

-/// \returns true if all replacements apply. false otherwise.

-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 all

-/// replacements are applied successfully, this returns the code with

-/// replacements applied; otherwise, an llvm::Error carrying llvm::StringError

-/// is returned (the Error message can be converted to string using

-/// `llvm::toString()` and 'std::error_code` in the `Error` should be ignored).

-llvm::Expected<std::string> applyAllReplacements(StringRef Code,

-                                                 const Replacements &Replaces);

-

-/// \brief Calculates how a code \p Position is shifted when \p Replaces are

-/// applied.

-unsigned shiftedCodePosition(const Replacements& Replaces, unsigned Position);

-

-/// \brief Calculates how a code \p Position is shifted when \p Replaces are

-/// applied.

-///

-/// \pre Replaces[i].getOffset() <= Replaces[i+1].getOffset().

-unsigned shiftedCodePosition(const std::vector<Replacement> &Replaces,

-                             unsigned Position);

-

-/// \brief Removes duplicate Replacements and reports if Replacements conflict

-/// with one another. All Replacements are assumed to be in the same file.

-///

-/// \post Replaces[i].getOffset() <= Replaces[i+1].getOffset().

-///

-/// This function sorts \p Replaces so that conflicts can be reported simply by

-/// offset into \p Replaces and number of elements in the conflict.

-void deduplicate(std::vector<Replacement> &Replaces,

-                 std::vector<Range> &Conflicts);

-

-/// \brief Collection of Replacements generated from a single translation unit.

-struct TranslationUnitReplacements {

-  /// Name of the main source for the translation unit.

-  std::string MainSourceFile;

-

-  /// A freeform chunk of text to describe the context of the replacements.

-  /// Will be printed, for example, when detecting conflicts during replacement

-  /// deduplication.

-  std::string Context;

-

-  std::vector<Replacement> Replacements;

-};

-

-/// \brief Calculates the ranges in a single file that are affected by the

-/// Replacements. Overlapping ranges will be merged.

-///

-/// \pre Replacements must be for the same file.

-///

-/// \returns a non-overlapping and sorted ranges.

-std::vector<Range> calculateChangedRanges(const Replacements &Replaces);

-

-/// \brief Calculates the new ranges after \p Replaces are applied. These

-/// include both the original \p Ranges and the affected ranges of \p Replaces

-/// in the new code.

-///

-/// \pre Replacements must be for the same file.

-///

-/// \return The new ranges after \p Replaces are applied. The new ranges will be

-/// sorted and non-overlapping.

-std::vector<Range>

-calculateRangesAfterReplacements(const Replacements &Replaces,

-                                 const std::vector<Range> &Ranges);

-

-/// \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>

-Replacement::Replacement(const SourceManager &Sources,

-                         const Node &NodeToReplace, StringRef ReplacementText,

-                         const LangOptions &LangOpts) {

-  const CharSourceRange Range =

-      CharSourceRange::getTokenRange(NodeToReplace->getSourceRange());

-  setFromSourceRange(Sources, Range, ReplacementText, LangOpts);

+        struct TranslationUnitDiagnostics {

+            std::string MainSourceFile;

+            std::string Context;

+            std::vector<Diagnostics> Diags;

+        };

+    }

 }

-

-} // end namespace tooling

-} // end namespace clang

-

-#endif // LLVM_CLANG_TOOLING_CORE_REPLACEMENT_H

+#endif

\ No newline at end of file

Index: lib/Tooling/Core/CMakeLists.txt

===================================================================

--- lib/Tooling/Core/CMakeLists.txt	(revision 278390)

+++ lib/Tooling/Core/CMakeLists.txt	(working copy)

@@ -3,6 +3,7 @@

 add_clang_library(clangToolingCore

   Lookup.cpp

   Replacement.cpp

+  Diagnostics.cpp

   QualTypeNames.cpp

   LINK_LIBS

Index: lib/Tooling/Core/Diagnostics.cpp

===================================================================

--- lib/Tooling/Core/Diagnostics.cpp	(revision 278390)

+++ lib/Tooling/Core/Diagnostics.cpp	(working copy)

@@ -1,113 +1,30 @@

-//===--- Lookup.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.

-//

-//===----------------------------------------------------------------------===//

-//

-//  This file defines helper methods for clang tools performing name lookup.

-//

-//===----------------------------------------------------------------------===//

+#include "clang/Tooling/Core/Diagnostics.h"

+#include "clang/Basic/SourceManager.h"

+namespace clang {

+    namespace tooling {

-#include "clang/Tooling/Core/Lookup.h"

-#include "clang/AST/Decl.h"

-using namespace clang;

-using namespace clang::tooling;

+        DiagnosticsMessage::DiagnosticsMessage(StringRef Message)

+        : Message(Message), FileOffset(0) {

+        }

-static bool isInsideDifferentNamespaceWithSameName(const DeclContext *DeclA,

-                                                   const DeclContext *DeclB) {

-  while (true) {

-    // Look past non-namespaces on DeclA.

-    while (DeclA && !isa<NamespaceDecl>(DeclA))

-      DeclA = DeclA->getParent();

+        DiagnosticsMessage::DiagnosticsMessage(StringRef Message,

+                const SourceManager &Sources,

+                SourceLocation Loc)

+        : Message(Message) {

+            assert(Loc.isValid() && Loc.isFileID());

+            FilePath = Sources.getFilename(Loc);

+            FileOffset = Sources.getFileOffset(Loc);

+        }

-    // Look past non-namespaces on DeclB.

-    while (DeclB && !isa<NamespaceDecl>(DeclB))

-      DeclB = DeclB->getParent();

+        Diagnostics::Diagnostics() {

+        }

-    // We hit the root, no namespace collision.

-    if (!DeclA || !DeclB)

-      return false;

-

-    // Literally the same namespace, not a collision.

-    if (DeclA == DeclB)

-      return false;

-

-    // Now check the names. If they match we have a different namespace with the

-    // same name.

-    if (cast<NamespaceDecl>(DeclA)->getDeclName() ==

-        cast<NamespaceDecl>(DeclB)->getDeclName())

-      return true;

-

-    DeclA = DeclA->getParent();

-    DeclB = DeclB->getParent();

-  }

-}

-

-static StringRef getBestNamespaceSubstr(const DeclContext *DeclA,

-                                        StringRef NewName,

-                                        bool HadLeadingColonColon) {

-  while (true) {

-    while (DeclA && !isa<NamespaceDecl>(DeclA))

-      DeclA = DeclA->getParent();

-

-    // Fully qualified it is! Leave :: in place if it's there already.

-    if (!DeclA)

-      return HadLeadingColonColon ? NewName : NewName.substr(2);

-

-    // Otherwise strip off redundant namespace qualifications from the new name.

-    // We use the fully qualified name of the namespace and remove that part

-    // from NewName if it has an identical prefix.

-    std::string NS =

-        "::" + cast<NamespaceDecl>(DeclA)->getQualifiedNameAsString() + "::";

-    if (NewName.startswith(NS))

-      return NewName.substr(NS.size());

-

-    // No match yet. Strip of a namespace from the end of the chain and try

-    // again. This allows to get optimal qualifications even if the old and new

-    // decl only share common namespaces at a higher level.

-    DeclA = DeclA->getParent();

-  }

-}

-

-/// Check if the name specifier begins with a written "::".

-static bool isFullyQualified(const NestedNameSpecifier *NNS) {

-  while (NNS) {

-    if (NNS->getKind() == NestedNameSpecifier::Global)

-      return true;

-    NNS = NNS->getPrefix();

-  }

-  return false;

-}

-

-std::string tooling::replaceNestedName(const NestedNameSpecifier *Use,

-                                       const DeclContext *UseContext,

-                                       const NamedDecl *FromDecl,

-                                       StringRef ReplacementString) {

-  assert(ReplacementString.startswith("::") &&

-         "Expected fully-qualified name!");

-

-  // We can do a raw name replacement when we are not inside the namespace for

-  // the original function and it is not in the global namespace.  The

-  // assumption is that outside the original namespace we must have a using

-  // statement that makes this work out and that other parts of this refactor

-  // will automatically fix using statements to point to the new function

-  const bool class_name_only = !Use;

-  const bool in_global_namespace =

-      isa<TranslationUnitDecl>(FromDecl->getDeclContext());

-  if (class_name_only && !in_global_namespace &&

-      !isInsideDifferentNamespaceWithSameName(FromDecl->getDeclContext(),

-                                              UseContext)) {

-    auto Pos = ReplacementString.rfind("::");

-    return Pos != StringRef::npos ? ReplacementString.substr(Pos + 2)

-                                  : ReplacementString;

-  }

-  // We did not match this because of a using statement, so we will need to

-  // figure out how good a namespace match we have with our destination type.

-  // We work backwards (from most specific possible namespace to least

-  // specific).

-  return getBestNamespaceSubstr(UseContext, ReplacementString,

-                                isFullyQualified(Use));

-}

+        Diagnostics::Diagnostics(StringRef CheckName,

+                Diagnostics::Level DiagLevel,

+                bool IsWarningAsError,

+                StringRef BuildDirectory)

+        : CheckName(CheckName), BuildDirectory(BuildDirectory), DiagLevel(DiagLevel),

+        IsWarningAsError(IsWarningAsError) {

+        }

+    }

+}

\ No newline at end of file