[clang-diff] Rename ChangeKind::None to NoChange

include/clang/Tooling/ASTDiff/ASTDiff.h

 #define LLVM_CLANG_TOOLING_ASTDIFF_ASTDIFF_H
 
 #include "clang/Tooling/ASTDiff/ASTDiffInternal.h"
 
 namespace clang {
 namespace diff {
 
 enum ChangeKind {
-  None,
+  NoChange,
   Delete,    // (Src): delete node Src.
   Update,    // (Src, Dst): update the value of node Src to match Dst.
   Insert,    // (Src, Dst, Pos): insert Src as child of Dst at offset Pos.
   Move,      // (Src, Dst, Pos): move Src to be a child of Dst at offset Pos.
   UpdateMove // Same as Move plus Update.
 };
 
 using NodeRef = const Node &;

 
 /// Represents a Clang AST node, alongside some additional information.
 struct Node {
   SyntaxTree::Impl &Tree;
   NodeId Parent, LeftMostDescendant, RightMostDescendant;
   int Depth, Height, Shift = 0;
   ast_type_traits::DynTypedNode ASTNode;
   SmallVector<NodeId, 4> Children;
-  ChangeKind Change = None;
+  ChangeKind Change = NoChange;
   Node(SyntaxTree::Impl &Tree) : Tree(Tree), Children() {}
 
   NodeId getId() const;
   SyntaxTree &getTree() const;
   const Node *getParent() const;
   NodeRef getChild(size_t Index) const;
   size_t getNumChildren() const { return Children.size(); }
   ast_type_traits::ASTNodeKind getType() const;

tools/clang-diff/ClangDiff.cpp

 
 static void printHtml(raw_ostream &OS, const StringRef Str) {
   for (char C : Str)
     printHtml(OS, C);
 }
 
 static std::string getChangeKindAbbr(diff::ChangeKind Kind) {
   switch (Kind) {
-  case diff::None:
+  case diff::NoChange:
     return "";
   case diff::Delete:
     return "d";
   case diff::Update:
     return "u";
   case diff::Insert:
     return "i";
   case diff::Move:
static unsigned printHtmlForNode(raw_ostream &OS, const diff::ASTDiff &Diff,
   printHtml(OS, Node.getTypeLabel());
   OS << "\n" << LeftId << " -> " << RightId;
   std::string Value = Tree.getNodeValue(Node);
   if (!Value.empty()) {
     OS << "\n";
     printHtml(OS, Value);
   }
   OS << "'";
-  if (Node.Change != diff::None)
+  if (Node.Change != diff::NoChange)
     OS << " class='" << getChangeKindAbbr(Node.Change) << "'";
   OS << ">";
 
   for (diff::NodeRef Child : Node)
     Offset = printHtmlForNode(OS, Diff, IsLeft, Child, Offset);
 
   for (; Offset < End; ++Offset)
     printHtml(OS, Code[Offset]);
static void printTree(raw_ostream &OS, diff::SyntaxTree &Tree) {
   }
 }
 
 static void printDstChange(raw_ostream &OS, diff::ASTDiff &Diff,
                            diff::SyntaxTree &SrcTree, diff::SyntaxTree &DstTree,
                            diff::NodeRef Dst) {
   const diff::Node *Src = Diff.getMapped(DstTree, Dst);
   switch (Dst.Change) {
-  case diff::None:
+  case diff::NoChange:
     break;
   case diff::Delete:
     llvm_unreachable("The destination tree can't have deletions.");
   case diff::Update:
     OS << "Update ";
     printNode(OS, SrcTree, *Src);
     OS << " to " << DstTree.getNodeValue(Dst) << "\n";
     break;