[clang-diff] Remove getNodeValue

include/clang/Tooling/ASTDiff/ASTDiff.h

public:
   NodeRef getRoot() const;
   NodeId getRootId() const;
   using PreorderIterator = const Node *;
   PreorderIterator begin() const;
   PreorderIterator end() const;
 
   NodeRef getNode(NodeId Id) const;
 
-  /// Serialize the node attributes to a string representation. This should
-  /// uniquely distinguish nodes of the same kind. Note that this function
-  /// just
-  /// returns a representation of the node value, not considering descendants.
-  std::string getNodeValue(NodeRef Node) const;
-
   class Impl;
   std::unique_ptr<Impl> TreeImpl;
 };
 
 /// Represents a Clang AST node, alongside some additional information.
 struct Node {
   SyntaxTree::Impl &Tree;
   NodeId Parent, LeftMostDescendant, RightMostDescendant;

lib/Tooling/ASTDiff/ASTDiff.cpp

public:
   NodeId getRootId() const { return 0; }
   PreorderIterator begin() const { return &getRoot(); }
   PreorderIterator end() const { return begin() + getSize(); }
 
   NodeRef getNode(NodeId Id) const { return Nodes[Id]; }
   Node &getMutableNode(NodeId Id) { return Nodes[Id]; }
   Node &getMutableNode(NodeRef N) { return getMutableNode(N.getId()); }
 
-  std::string getRelativeName(const NamedDecl *ND,
-                              const DeclContext *Context) const;
-  std::string getRelativeName(const NamedDecl *ND) const;
-
-  std::string getNodeValue(NodeRef Node) const;
-  std::string getDeclValue(const Decl *D) const;
-  std::string getStmtValue(const Stmt *S) const;
-
 private:
   void initTree();
   void setLeftMostDescendants();
 };
 
 NodeRef NodeRefIterator::operator*() const { return Tree->getNode(*IdPointer); }
 
 NodeRefIterator &NodeRefIterator::operator++() { return ++IdPointer, *this; }
static int getNumberOfDescendants(NodeRef N) {
   return N.RightMostDescendant - N.getId() + 1;
 }
 
 static bool isInSubtree(NodeRef N, NodeRef SubtreeRoot) {
   return N.getId() >= SubtreeRoot.getId() &&
          N.getId() <= SubtreeRoot.RightMostDescendant;
 }
 
-// Returns the qualified name of ND. If it is subordinate to Context,
-// then the prefix of the latter is removed from the returned value.
-std::string
-SyntaxTree::Impl::getRelativeName(const NamedDecl *ND,
-                                  const DeclContext *Context) const {
-  std::string Val = ND->getQualifiedNameAsString();
-  std::string ContextPrefix;
-  if (!Context)
-    return Val;
-  if (auto *Namespace = dyn_cast<NamespaceDecl>(Context))
-    ContextPrefix = Namespace->getQualifiedNameAsString();
-  else if (auto *Record = dyn_cast<RecordDecl>(Context))
-    ContextPrefix = Record->getQualifiedNameAsString();
-  else if (AST.getLangOpts().CPlusPlus11)
-    if (auto *Tag = dyn_cast<TagDecl>(Context))
-      ContextPrefix = Tag->getQualifiedNameAsString();
-  // Strip the qualifier, if Val refers to somthing in the current scope.
-  // But leave one leading ':' in place, so that we know that this is a
-  // relative path.
-  if (!ContextPrefix.empty() && StringRef(Val).startswith(ContextPrefix))
-    Val = Val.substr(ContextPrefix.size() + 1);
-  return Val;
-}
-
-std::string SyntaxTree::Impl::getRelativeName(const NamedDecl *ND) const {
-  return getRelativeName(ND, ND->getDeclContext());
-}
-
-static const DeclContext *getEnclosingDeclContext(ASTUnit &AST, const Stmt *S) {
-  while (S) {
-    const auto &Parents = AST.getASTContext().getParents(*S);
-    if (Parents.empty())
-      return nullptr;
-    const auto &P = Parents[0];
-    if (const auto *D = P.get<Decl>())
-      return D->getDeclContext();
-    S = P.get<Stmt>();
-  }
-  return nullptr;
-}
-
-static std::string getInitializerValue(const CXXCtorInitializer *Init,
-                                       const PrintingPolicy &TypePP) {
-  if (Init->isAnyMemberInitializer())
-    return Init->getAnyMember()->getName();
-  if (Init->isBaseInitializer())
-    return QualType(Init->getBaseClass(), 0).getAsString(TypePP);
-  if (Init->isDelegatingInitializer())
-    return Init->getTypeSourceInfo()->getType().getAsString(TypePP);
-  llvm_unreachable("Unknown initializer type");
-}
-
-std::string SyntaxTree::Impl::getNodeValue(NodeRef N) const {
-  assert(&N.Tree == this);
-  const DynTypedNode &DTN = N.ASTNode;
-  if (N.isMacro()) {
-    return Lexer::getSourceText(N.getSourceRange(), AST.getSourceManager(),
-                                AST.getLangOpts());
-  }
-  if (auto *S = DTN.get<Stmt>())
-    return getStmtValue(S);
-  if (auto *D = DTN.get<Decl>())
-    return getDeclValue(D);
-  if (auto *Init = DTN.get<CXXCtorInitializer>())
-    return getInitializerValue(Init, TypePP);
-  llvm_unreachable("Fatal: unhandled AST node.\n");
-}
-
-std::string SyntaxTree::Impl::getDeclValue(const Decl *D) const {
-  std::string Value;
-  if (auto *V = dyn_cast<ValueDecl>(D))
-    return getRelativeName(V) + "(" + V->getType().getAsString(TypePP) + ")";
-  if (auto *N = dyn_cast<NamedDecl>(D))
-    Value += getRelativeName(N) + ";";
-  if (auto *T = dyn_cast<TypedefNameDecl>(D))
-    return Value + T->getUnderlyingType().getAsString(TypePP) + ";";
-  if (auto *T = dyn_cast<TypeDecl>(D))
-    if (T->getTypeForDecl())
-      Value +=
-          T->getTypeForDecl()->getCanonicalTypeInternal().getAsString(TypePP) +
-          ";";
-  if (auto *U = dyn_cast<UsingDirectiveDecl>(D))
-    return U->getNominatedNamespace()->getName();
-  if (auto *A = dyn_cast<AccessSpecDecl>(D)) {
-    CharSourceRange Range(A->getSourceRange(), false);
-    return Lexer::getSourceText(Range, AST.getSourceManager(),
-                                AST.getLangOpts());
-  }
-  return Value;
-}
-
-std::string SyntaxTree::Impl::getStmtValue(const Stmt *S) const {
-  if (auto *U = dyn_cast<UnaryOperator>(S))
-    return UnaryOperator::getOpcodeStr(U->getOpcode());
-  if (auto *B = dyn_cast<BinaryOperator>(S))
-    return B->getOpcodeStr();
-  if (auto *M = dyn_cast<MemberExpr>(S))
-    return getRelativeName(M->getMemberDecl());
-  if (auto *I = dyn_cast<IntegerLiteral>(S)) {
-    SmallString<256> Str;
-    I->getValue().toString(Str, /*Radix=*/10, /*Signed=*/false);
-    return Str.str();
-  }
-  if (auto *F = dyn_cast<FloatingLiteral>(S)) {
-    SmallString<256> Str;
-    F->getValue().toString(Str);
-    return Str.str();
-  }
-  if (auto *D = dyn_cast<DeclRefExpr>(S))
-    return getRelativeName(D->getDecl(), getEnclosingDeclContext(AST, S));
-  if (auto *String = dyn_cast<StringLiteral>(S))
-    return String->getString();
-  if (auto *B = dyn_cast<CXXBoolLiteralExpr>(S))
-    return B->getValue() ? "true" : "false";
-  return "";
-}
-
 static HashType hashNode(NodeRef N) {
   llvm::MD5 Hash;
   SourceManager &SM = N.getTree().getSourceManager();
   const LangOptions &LangOpts = N.getTree().getLangOpts();
   Token Tok;
   for (auto TokenLocation : N.getOwnedTokens()) {
     bool Failure = Lexer::getRawToken(TokenLocation, Tok, SM, LangOpts,
                                       /*IgnoreWhiteSpace=*/true);
public:
   SNodeId getLeftMostDescendant(SNodeId Id) const {
     assert(Id > 0 && Id <= getSize() && "Invalid subtree node index.");
     return LeftMostDescendants[Id - 1];
   }
   /// Returns the postorder index of the leftmost descendant in the subtree.
   NodeId getPostorderOffset() const {
     return Tree.PostorderIds[getIdInRoot(SNodeId(1))];
   }
-  std::string getNodeValue(SNodeId Id) const {
-    return Tree.getNodeValue(getNode(Id));
-  }
 
 private:
   /// Returns the number of leafs in the subtree.
   int setLeftMostDescendants() {
     int NumLeaves = 0;
     LeftMostDescendants.resize(getSize());
     for (int I = 0; I < getSize(); ++I) {
       SNodeId SI(I + 1);

 int SyntaxTree::getSize() const { return TreeImpl->getSize(); }
 NodeRef SyntaxTree::getRoot() const { return TreeImpl->getRoot(); }
 NodeId SyntaxTree::getRootId() const { return TreeImpl->getRootId(); }
 SyntaxTree::PreorderIterator SyntaxTree::begin() const {
   return TreeImpl->begin();
 }
 SyntaxTree::PreorderIterator SyntaxTree::end() const { return TreeImpl->end(); }
 
-std::string SyntaxTree::getNodeValue(NodeRef N) const {
-  return TreeImpl->getNodeValue(N);
-}
-
 } // end namespace diff
 } // end namespace clang

test/Tooling/clang-diff-ast.cpp

 // RUN: clang-diff -ast-dump %s -- -std=c++11 | FileCheck %s
 
 
 // CHECK: {{^}}TranslationUnitDecl(0)
-// CHECK: {{^}} NamespaceDecl: test;(
+// CHECK: {{^}} NamespaceDecl(1)
 namespace test {
 
-// CHECK: {{^}} FunctionDecl: :f(
-// CHECK: CompoundStmt(
+// CHECK: {{^}} FunctionDecl(2)
+// CHECK: CompoundStmt(3)
 void f() {
-  // CHECK: VarDecl: i(int)(
-  // CHECK: IntegerLiteral: 1
+  // CHECK: DeclStmt(4)
+  // CHECK: VarDecl(5)
+  // CHECK: IntegerLiteral(6)
   auto i = 1;
-  // CHECK: FloatingLiteral: 1.5(
+  // CHECK: FloatingLiteral(9)
   auto r = 1.5;
-  // CHECK: CXXBoolLiteralExpr: true(
+  // CHECK: CXXBoolLiteralExpr(12)
   auto b = true;
-  // CHECK: CallExpr(
+  // CHECK: CallExpr(13)
   // CHECK-NOT: ImplicitCastExpr
-  // CHECK: DeclRefExpr: :f(
+  // CHECK: DeclRefExpr(14)
   f();
-  // CHECK: UnaryOperator: ++(
+  // CHECK: UnaryOperator(15)
   ++i;
-  // CHECK: BinaryOperator: =(
+  // CHECK: BinaryOperator(17)
   i = i;
 }
 
 } // end namespace test
 
-// CHECK: UsingDirectiveDecl: test(
+// CHECK: UsingDirectiveDecl(20)
 using namespace test;
 
-// CHECK: TypedefDecl: nat;unsigned int;(
+// CHECK: TypedefDecl(21)
 typedef unsigned nat;
-// CHECK: TypeAliasDecl: real;double;(
+// CHECK: TypeAliasDecl(22)
 using real = double;
 
 class Base {
 };
 
-// CHECK: CXXRecordDecl: X;X;(
+// CHECK: CXXRecordDecl(23)
 class X : Base {
   int m;
-  // CHECK: CXXMethodDecl: :foo(const char *(int)
-  // CHECK: ParmVarDecl: i(int)(
+  // CHECK: CXXMethodDecl(26)
+  // CHECK: ParmVarDecl(27)
   const char *foo(int i) {
     if (i == 0)
-      // CHECK: StringLiteral: foo(
+      // CHECK: StringLiteral(34)
       return "foo";
     // CHECK-NOT: ImplicitCastExpr
     return 0;
   }
 
-  // CHECK: AccessSpecDecl: public(
+  // CHECK: AccessSpecDecl(37)
 public:
   int not_initialized;
-  // CHECK: CXXConstructorDecl: :X(void (char, int){{( __attribute__\(\(thiscall\)\))?}})(
-  // CHECK-NEXT: ParmVarDecl: s(char)
-  // CHECK-NEXT: ParmVarDecl: (int)
-  // CHECK-NEXT: CXXCtorInitializer: Base
-  // CHECK-NEXT: CXXConstructExpr
-  // CHECK-NEXT: CXXCtorInitializer: m
-  // CHECK-NEXT: IntegerLiteral: 0
+  // CHECK: CXXConstructorDecl(39)
+  // CHECK-NEXT: ParmVarDecl(40)
+  // CHECK-NEXT: ParmVarDecl(41)
+  // CHECK-NEXT: CXXCtorInitializer(42)
+  // CHECK-NEXT: CXXConstructExpr(43)
+  // CHECK-NEXT: CXXCtorInitializer(44)
+  // CHECK-NEXT: IntegerLiteral(45)
   X(char s, int) : Base(), m(0) {
-    // CHECK-NEXT: CompoundStmt
-    // CHECK: MemberExpr: :m(
+    // CHECK-NEXT: CompoundStmt(46)
+    // CHECK: MemberExpr(49)
     int x = m;
   }
-  // CHECK: CXXConstructorDecl: :X(void (char){{( __attribute__\(\(thiscall\)\))?}})(
-  // CHECK: CXXCtorInitializer: X
+  // CHECK: CXXConstructorDecl(51)
+  // CHECK: CXXCtorInitializer(53)
   X(char s) : X(s, 4) {}
 };
 
 #define M (void)1
 #define F(a, b) (void)a, b
 void macros() {
-  // CHECK: Macro: M(
+  // CHECK: Macro(60)
   M;
   // two expressions, therefore it occurs twice
-  // CHECK-NEXT: Macro: F(1, 2)(
-  // CHECK-NEXT: Macro: F(1, 2)(
+  // CHECK-NEXT: Macro(61)
+  // CHECK-NEXT: Macro(62)
   F(1, 2);
 }
 
 #ifndef GUARD
 #define GUARD
-// CHECK-NEXT: NamespaceDecl
+// CHECK-NEXT: NamespaceDecl(63)
 namespace world {
 // nodes from other files are excluded, there should be no output here
 #include "clang-diff-ast.cpp"
 }
-// CHECK-NEXT: FunctionDecl: sentinel
+// CHECK-NEXT: FunctionDecl(64)
 void sentinel();
 #endif

test/Tooling/clang-diff-basic.cpp

 // RUN: clang-diff -dump-matches %S/Inputs/clang-diff-basic-src.cpp %s -- | FileCheck %s
 
-// CHECK: Match TranslationUnitDecl{{.*}} to TranslationUnitDecl
-// CHECK: Match NamespaceDecl: src{{.*}} to NamespaceDecl: dst
+// CHECK: Match TranslationUnitDecl(0) to TranslationUnitDecl(0)
+// CHECK: Match NamespaceDecl(1) to NamespaceDecl(1)
 namespace dst {
-// CHECK-NOT: Match NamespaceDecl: src{{.*}} to NamespaceDecl: inner
+// CHECK-NOT: Match NamespaceDecl(1) to NamespaceDecl(2)
 namespace inner {
 void foo() {
-  // CHECK: Match IntegerLiteral: 321{{.*}} to IntegerLiteral: 322
+  // CHECK: Match IntegerLiteral(6) to IntegerLiteral(7)
   int x = 322;
 }
 }
 
-// CHECK: Match DeclRefExpr: :foo{{.*}} to DeclRefExpr: :inner::foo
+// CHECK: Match DeclRefExpr(10) to DeclRefExpr(11)
 void main() { inner::foo(); }
 
-// CHECK: Match StringLiteral: foo{{.*}} to StringLiteral: foo
+// CHECK: Match StringLiteral(13) to StringLiteral(13)
 const char *b = "f" "o" "o";
 
 // unsigned is canonicalized to unsigned int
-// CHECK: Match TypedefDecl: :nat;unsigned int;{{.*}} to TypedefDecl: :nat;unsigned int;
+// CHECK: Match TypedefDecl(14) to TypedefDecl(14)
 typedef unsigned nat;
 
-// CHECK: Match VarDecl: :p(int){{.*}} to VarDecl: :prod(double)
-// CHECK: Update VarDecl: :p(int){{.*}} to :prod(double)
-// CHECK: Match BinaryOperator: *{{.*}} to BinaryOperator: *
+// CHECK: Match VarDecl(15)
+// CHECK: Update VarDecl(15)
+// CHECK: Match BinaryOperator(17)
 double prod = 1 * 2 * 10;
-// CHECK: Update DeclRefExpr
+// CHECK: Update DeclRefExpr(25)
 int squared = prod * prod;
 
 class X {
   const char *foo(int i) {
     // CHECK: Insert IfStmt(29) into CompoundStmt(28)
     if (i == 0)
       return "Bar";
     // CHECK: Move IfStmt(35) into IfStmt
     else if (i == -1)
       return "foo";
     return 0;
   }
   X(){}
 };
 }
 
-// CHECK: Move CompoundStmt{{.*}} into CompoundStmt
+// CHECK: Move CompoundStmt(48) into CompoundStmt(47)
 void m() { { int x = 0 + 0 + 0; } }
-// CHECK: Update and Move IntegerLiteral: 7{{.*}} into BinaryOperator: +({{.*}}) at 1
+// CHECK: Update and Move IntegerLiteral(59) into BinaryOperator(57) at 1
 int um = 1 + 7;
 
 namespace {
 // match with parents of different type
-// CHECK: Match FunctionDecl: f1{{.*}} to FunctionDecl: (anonymous namespace)::f1
+// CHECK: Match FunctionDecl(70) to FunctionDecl(69)
 void f1() {{ (void) __func__;;; }}
 }
 
 // macros are always compared by their full textual value
 
 #define M1 return 1 + 1
 #define M2 return 2 * 2
 #define F(a, b) return a + b;
 
 int f2() {
-  // CHECK: Match Macro: M1{{.*}} to Macro: M1
+  // CHECK: Match Macro(72) to Macro(71)
   M1;
-  // CHECK: Update Macro: M1{{.*}} to M2
+  // CHECK: Update Macro(73)
   M2;
-  // CHECK: Match Macro: F(1, 1)(74)
+  // CHECK: Match Macro(74)
   F(1, /*b=*/1);
 }
 
-// CHECK: Delete AccessSpecDecl: public
-// CHECK: Delete CXXMethodDecl
+// CHECK: Delete AccessSpecDecl(39)
+// CHECK: Delete CXXMethodDecl(42)

test/Tooling/clang-diff-bottomup.cpp

 
 #else
 
 // Jaccard similarity threshold is 0.5.
 
 void f1() {
 // CompoundStmt: 3 matched descendants, subtree sizes 4 and 5
 // Jaccard similarity = 3 / (4 + 5 - 3) = 3 / 6 >= 0.5
-// CHECK: Match FunctionDecl: f1(void ())(1) to FunctionDecl: f1(void ())(1)
+// CHECK: Match FunctionDecl(1) to FunctionDecl(1)
 // CHECK: Match CompoundStmt(2) to CompoundStmt(2)
 // CHECK: Match CompoundStmt(4) to CompoundStmt(3)
 // CHECK: Match CompoundStmt(5) to CompoundStmt(4)
 // CHECK: Match NullStmt(6) to NullStmt(5)
   {{;}} ;;
 }
 
 void f2() {

test/Tooling/clang-diff-heuristics.cpp

 // RUN: %clang_cc1 -E %s > %t.src.cpp
 // RUN: %clang_cc1 -E %s > %t.dst.cpp -DDEST
 // RUN: clang-diff -dump-matches -s=0 %t.src.cpp %t.dst.cpp -- | FileCheck %s
 //
 // Test the heuristics, with maxsize set to 0, so that the optimal matching will never be applied.
 
 #ifndef DEST
 
 void f1() {;}
 
 void f2(int) {;}
 
 #else
 
 // same parents, same value
-// CHECK: Match FunctionDecl: f1(void ())(1) to FunctionDecl: f1(void ())(1)
+// CHECK: Match FunctionDecl(1) to FunctionDecl(1)
 // CHECK: Match CompoundStmt
 void f1() {}
 
 // same parents, same identifier
-// CHECK: Match FunctionDecl: f2(void (int))(4) to FunctionDecl: f2(void ())(3)
+// CHECK: Match FunctionDecl(4) to FunctionDecl(3)
 // CHECK: Match CompoundStmt
 void f2() {}
 
 #endif

test/Tooling/clang-diff-html.test

 RUN: clang-diff -html %S/Inputs/clang-diff-basic-src.cpp %S/clang-diff-basic.cpp -- | FileCheck %s
 
 CHECK: <pre><div id='L' class='code'><span id='L0' tid='R0' title='TranslationUnitDecl
 CHECK-NEXT: 0 -> 0' class='u'>
 
 match, update
 CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='NamespaceDecl
-CHECK-NEXT: [[L]] -> [[R]]
-CHECK-NEXT: src;' class='u'>namespace src {
+CHECK-NEXT: [[L]] -> [[R]]' class='u'>namespace src {
 
 match, move
 CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='FunctionDecl
-CHECK-NEXT: [[L]] -> [[R]]
-CHECK-NEXT: :foo(void ())' class='m'>void foo()
+CHECK-NEXT: [[L]] -> [[R]]' class='m'>void foo()
 
 match
 CHECK: <span id='L[[L:[0-9]+]]' tid='R[[R:[0-9]+]]' title='FunctionDecl
-CHECK-NEXT: [[L]] -> [[R]]
-CHECK-NEXT: :main(void ())'>void main()
+CHECK-NEXT: [[L]] -> [[R]]'>void main()
 
 deletion
 CHECK: <span id='L[[L:[0-9]+]]' tid='R-1' title='IntegerLiteral
-CHECK-NEXT: [[L]] -> -1
-CHECK-NEXT: 4' class='d'>4</span>
+CHECK-NEXT: [[L]] -> -1' class='d'>4</span>
 
 update + move
-CHECK: 2' class='u m'>2</span>
+CHECK: class='u m'>2</span>
 
 insertion
 CHECK: <span id='R[[R:[0-9]+]]' tid='L-1' title='StringLiteral
-CHECK-NEXT: -1 -> [[R]]
-CHECK-NEXT: Bar' class='i'>&quot;Bar&quot;</span>
+CHECK-NEXT: -1 -> [[R]]' class='i'>&quot;Bar&quot;</span>
 
 comments
-CHECK: // CHECK: Delete AccessSpecDecl: public
+CHECK: // CHECK: Delete AccessSpecDecl

test/Tooling/clang-diff-json.cpp

 // CHECK-NEXT: {
 // CHECK-NEXT: "begin":
 // CHECK-NEXT: "children": []
 // CHECK-NEXT: "end":
 // CHECK-NEXT: "id":
 // CHECK-NEXT: "type": "CharacterLiteral"
 // CHECK-NEXT: }
 // CHECK: ]
-// CHECK: "type": "VarDecl",
+// CHECK: "type": "VarDecl"
 char nl = '\n';
-
-// CHECK: "value": "abc \n\t\u0000\u001f"
-char s[] = "abc \n\t\0\x1f";
-

test/Tooling/clang-diff-topdown.cpp

void f1() {
   // CHECK-NOT: Match {{.*}} to NullStmt(14)
   ;
 }
 
 int x;
 
 namespace dst {
   int x;
-  // CHECK: Match DeclRefExpr: :x(17) to DeclRefExpr: :x(22)
+  // CHECK: Match DeclRefExpr(17) to DeclRefExpr(22)
   int x1 = x + 1;
-  // CHECK: Match DeclRefExpr: x(21) to DeclRefExpr: x(26)
+  // CHECK: Match DeclRefExpr(21) to DeclRefExpr(26)
   int x2 = ::x + 1;
 }
 
 #endif

tools/clang-diff/ClangDiff.cpp

static unsigned printHtmlForNode(raw_ostream &OS, const diff::ASTDiff &Diff,
   const SourceManager &SM = Tree.getASTContext().getSourceManager();
   auto Code = SM.getBuffer(SM.getMainFileID())->getBuffer();
   for (; Offset < Begin; ++Offset)
     printHtml(OS, Code[Offset]);
   OS << "<span id='" << MyTag << Node.getId() << "' "
      << "tid='" << OtherTag << TargetId << "' ";
   OS << "title='";
   printHtml(OS, Node.getTypeLabel());
-  OS << "\n" << LeftId << " -> " << RightId;
-  std::string Value = Tree.getNodeValue(Node);
-  if (!Value.empty()) {
-    OS << "\n";
-    printHtml(OS, Value);
-  }
-  OS << "'";
+  OS << "\n" << LeftId << " -> " << RightId << "'";
   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)

 
 static void printNodeAttributes(raw_ostream &OS, diff::SyntaxTree &Tree,
                                 diff::NodeRef Node) {
   OS << R"("id":)" << int(Node.getId());
   OS << R"(,"type":")" << Node.getTypeLabel() << '"';
   auto Offsets = Node.getSourceRangeOffsets();
   OS << R"(,"begin":)" << Offsets.first;
   OS << R"(,"end":)" << Offsets.second;
-  std::string Value = Tree.getNodeValue(Node);
-  if (!Value.empty()) {
-    OS << R"(,"value":")";
-    printJsonString(OS, Value);
-    OS << '"';
-  }
 }
 
 static void printNodeAsJson(raw_ostream &OS, diff::SyntaxTree &Tree,
                             diff::NodeRef Node) {
   OS << "{";
   printNodeAttributes(OS, Tree, Node);
   auto Identifier = Node.getIdentifier();
   auto QualifiedIdentifier = Node.getQualifiedIdentifier();
if (ChildBegin != ChildEnd) {
     }
   }
   OS << "]}";
 }
 
 static void printNode(raw_ostream &OS, diff::SyntaxTree &Tree,
                       diff::NodeRef Node) {
   OS << Node.getTypeLabel();
-  std::string Value = Tree.getNodeValue(Node);
-  if (!Value.empty())
-    OS << ": " << Value;
   OS << "(" << Node.getId() << ")";
 }
 
 static void printTree(raw_ostream &OS, diff::SyntaxTree &Tree) {
   for (diff::NodeRef Node : Tree) {
     for (int I = 0; I < Node.Depth; ++I)
       OS << " ";
     printNode(OS, Tree, Node);
     OS << "\n";
   }
 }
 
 static void printDstChange(raw_ostream &OS, diff::ASTDiff &Diff,
                            diff::SyntaxTree &SrcTree, diff::SyntaxTree &DstTree,
                            diff::NodeRef Dst) {
   const diff::Node *Src = Diff.getMapped(Dst);
   switch (Dst.Change) {
   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";
+    OS << "\n";
     break;
   case diff::Insert:
   case diff::Move:
   case diff::UpdateMove:
     if (Dst.Change == diff::Insert)
       OS << "Insert";
     else if (Dst.Change == diff::Move)
       OS << "Move";