Index: lib/Tooling/ASTDiff/ASTDiff.cpp
===================================================================
--- lib/Tooling/ASTDiff/ASTDiff.cpp
+++ lib/Tooling/ASTDiff/ASTDiff.cpp
@@ -15,7 +15,7 @@
 
 #include "clang/AST/DataCollection.h"
 #include "clang/AST/DeclVisitor.h"
-#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/LexicallyOrderedRecursiveASTVisitor.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/PriorityQueue.h"
@@ -149,6 +149,7 @@
   // Maps preorder indices to postorder ones.
   std::vector<int> PostorderIds;
   std::vector<NodeId> NodesBfs;
+  std::map<NodeId, SourceRange> TemplateArgumentLocations;
 
   int getSize() const { return Nodes.size(); }
   NodeId getRootId() const { return 0; }
@@ -186,6 +187,14 @@
 static bool isSpecializedNodeExcluded(CXXCtorInitializer *I) {
   return !I->isWritten();
 }
+static bool isSpecializedNodeExcluded(const TemplateArgumentLoc *S) {
+  return false;
+}
+
+static bool isNodeExcluded(ASTUnit &AST, TemplateName *Template) {
+  // TODO what if it is from another file
+  return false;
+}
 
 template <class T> static bool isNodeExcluded(ASTUnit &AST, T *N) {
   const SourceManager &SrcMgr = AST.getSourceManager();
@@ -203,9 +212,8 @@
   return isSpecializedNodeExcluded(N);
 }
 
-static SourceRange getSourceRange(const ASTUnit &AST, const DynTypedNode &DTN) {
+static SourceRange getSourceExtent(const ASTUnit &AST, SourceRange Range) {
   const SourceManager &SrcMgr = AST.getSourceManager();
-  SourceRange Range = DTN.getSourceRange();
   SourceLocation BeginLoc = Range.getBegin();
   SourceLocation EndLoc;
   if (BeginLoc.isMacroID())
@@ -214,29 +222,29 @@
     EndLoc = Range.getEnd();
   EndLoc = Lexer::getLocForEndOfToken(EndLoc, /*Offset=*/0, SrcMgr,
                                       AST.getLangOpts());
-  if (auto *ThisExpr = DTN.get<CXXThisExpr>()) {
-    if (ThisExpr->isImplicit())
-      EndLoc = BeginLoc;
-  }
   return {SrcMgr.getExpansionLoc(BeginLoc), SrcMgr.getExpansionLoc(EndLoc)};
 }
 
 namespace {
 // Sets Height, Parent and Children for each node.
-struct PreorderVisitor : public RecursiveASTVisitor<PreorderVisitor> {
+struct PreorderVisitor
+    : public LexicallyOrderedRecursiveASTVisitor<PreorderVisitor> {
+  using BaseType = LexicallyOrderedRecursiveASTVisitor<PreorderVisitor>;
+
   int Id = 0, Depth = 0;
   NodeId Parent;
   SyntaxTree::Impl &Tree;
 
-  PreorderVisitor(SyntaxTree::Impl &Tree) : Tree(Tree) {}
+  PreorderVisitor(SyntaxTree::Impl &Tree)
+      : BaseType(Tree.AST.getSourceManager()), Tree(Tree) {}
 
-  template <class T> std::tuple<NodeId, NodeId> PreTraverse(T *ASTNode) {
+  template <class T> std::tuple<NodeId, NodeId> PreTraverse(const T &ASTNode) {
     NodeId MyId = Id;
     Tree.Nodes.emplace_back();
     Node &N = Tree.getMutableNode(MyId);
     N.Parent = Parent;
     N.Depth = Depth;
-    N.ASTNode = DynTypedNode::create(*ASTNode);
+    N.ASTNode = DynTypedNode::create(ASTNode);
     assert(!N.ASTNode.getNodeKind().isNone() &&
            "Expected nodes to have a valid kind.");
     if (Parent.isValid()) {
@@ -268,8 +276,8 @@
   bool TraverseDecl(Decl *D) {
     if (isNodeExcluded(Tree.AST, D))
       return true;
-    auto SavedState = PreTraverse(D);
-    RecursiveASTVisitor<PreorderVisitor>::TraverseDecl(D);
+    auto SavedState = PreTraverse(*D);
+    BaseType::TraverseDecl(D);
     PostTraverse(SavedState);
     return true;
   }
@@ -278,8 +286,8 @@
       S = S->IgnoreImplicit();
     if (isNodeExcluded(Tree.AST, S))
       return true;
-    auto SavedState = PreTraverse(S);
-    RecursiveASTVisitor<PreorderVisitor>::TraverseStmt(S);
+    auto SavedState = PreTraverse(*S);
+    BaseType::TraverseStmt(S);
     PostTraverse(SavedState);
     return true;
   }
@@ -287,8 +295,25 @@
   bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
     if (isNodeExcluded(Tree.AST, Init))
       return true;
-    auto SavedState = PreTraverse(Init);
-    RecursiveASTVisitor<PreorderVisitor>::TraverseConstructorInitializer(Init);
+    auto SavedState = PreTraverse(*Init);
+    BaseType::TraverseConstructorInitializer(Init);
+    PostTraverse(SavedState);
+    return true;
+  }
+  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
+    if (isNodeExcluded(Tree.AST, &ArgLoc))
+      return true;
+    Tree.TemplateArgumentLocations.emplace(Id, ArgLoc.getSourceRange());
+    auto SavedState = PreTraverse(ArgLoc.getArgument());
+    BaseType::TraverseTemplateArgumentLoc(ArgLoc);
+    PostTraverse(SavedState);
+    return true;
+  }
+  bool TraverseTemplateName(TemplateName Template) {
+    if (isNodeExcluded(Tree.AST, &Template))
+      return true;
+    auto SavedState = PreTraverse(Template);
+    BaseType::TraverseTemplateName(Template);
     PostTraverse(SavedState);
     return true;
   }
@@ -441,6 +466,13 @@
   llvm_unreachable("Unknown initializer type");
 }
 
+template <class T> static std::string dumpToString(const T &Object) {
+  std::string Str;
+  llvm::raw_string_ostream OS(Str);
+  Object.dump(OS);
+  return OS.str();
+}
+
 std::string SyntaxTree::Impl::getNodeValue(NodeId Id) const {
   return getNodeValue(getNode(Id));
 }
@@ -448,7 +480,8 @@
 std::string SyntaxTree::Impl::getNodeValue(const Node &N) const {
   const DynTypedNode &DTN = N.ASTNode;
   if (N.isMacro()) {
-    CharSourceRange Range(getSourceRange(AST, N.ASTNode), false);
+    CharSourceRange Range(getSourceExtent(AST, N.ASTNode.getSourceRange()),
+                          false);
     return Lexer::getSourceText(Range, AST.getSourceManager(),
                                 AST.getLangOpts());
   }
@@ -458,7 +491,11 @@
     return getDeclValue(D);
   if (auto *Init = DTN.get<CXXCtorInitializer>())
     return getInitializerValue(Init, TypePP);
-  llvm_unreachable("Fatal: unhandled AST node.\n");
+  if (auto *Template = DTN.get<TemplateName>())
+    return dumpToString(*Template);
+  if (auto *Arg = DTN.get<TemplateArgument>())
+    return dumpToString(*Arg);
+  llvm_unreachable("getNodeValue: unhandled AST node.\n");
 }
 
 std::string SyntaxTree::Impl::getDeclValue(const Decl *D) const {
@@ -532,8 +569,12 @@
       ConstDeclVisitor<DataCollector>::Visit(D);
     else if (auto *Init = DTN.get<CXXCtorInitializer>())
       addData(getInitializerValue(Init, Tree.TypePP));
+    else if (auto *Template = DTN.get<TemplateName>())
+      addData(dumpToString(*Template));
+    else if (auto *Arg = DTN.get<TemplateArgument>())
+      addData(dumpToString(*Arg));
     else
-      llvm_unreachable("Fatal: unhandled AST node.\n");
+      llvm_unreachable("DataConsumer: unhandled AST node.\n");
   }
 
 #define DEF_ADD_DATA(CLASS, CODE)                                              \
@@ -587,7 +628,8 @@
 HashType SyntaxTree::Impl::hashNode(const Node &N) const {
   const DynTypedNode &DTN = N.ASTNode;
   if (N.isMacro()) {
-    CharSourceRange Range(getSourceRange(AST, N.ASTNode), false);
+    CharSourceRange Range(getSourceExtent(AST, N.ASTNode.getSourceRange()),
+                          false);
     return hashString(
         Lexer::getSourceText(Range, AST.getSourceManager(), AST.getLangOpts()));
   }
@@ -1200,7 +1242,16 @@
 std::pair<unsigned, unsigned>
 SyntaxTree::getSourceRangeOffsets(const Node &N) const {
   const SourceManager &SrcMgr = TreeImpl->AST.getSourceManager();
-  SourceRange Range = getSourceRange(TreeImpl->AST, N.ASTNode);
+  SourceRange Range;
+  if (auto *Arg = N.ASTNode.get<TemplateArgument>())
+    Range = TreeImpl->TemplateArgumentLocations.at(&N - &TreeImpl->Nodes[0]);
+  else {
+    Range = N.ASTNode.getSourceRange();
+    if (auto *ThisExpr = N.ASTNode.get<CXXThisExpr>())
+      if (ThisExpr->isImplicit())
+        Range.setEnd(Range.getBegin());
+  }
+  Range = getSourceExtent(TreeImpl->AST, Range);
   unsigned Begin = SrcMgr.getFileOffset(Range.getBegin());
   unsigned End = SrcMgr.getFileOffset(Range.getEnd());
   return {Begin, End};
Index: test/Tooling/Inputs/clang-diff-basic-src.cpp
===================================================================
--- test/Tooling/Inputs/clang-diff-basic-src.cpp
+++ test/Tooling/Inputs/clang-diff-basic-src.cpp
@@ -41,3 +41,16 @@
   M1;
   F(1, 1);
 }
+
+template <class T, class U = void>
+U visit(T &t) {
+  int x = t;
+  return U();
+}
+
+void tmp() {
+  int x;
+  visit<int>(x);
+}
+
+int x = 1;
Index: test/Tooling/clang-diff-ast.cpp
===================================================================
--- test/Tooling/clang-diff-ast.cpp
+++ test/Tooling/clang-diff-ast.cpp
@@ -92,3 +92,16 @@
 // CHECK-NEXT: FunctionDecl: sentinel
 void sentinel();
 #endif
+
+// CHECK-NEXT: ClassTemplateDecl: C
+// CHECK-NEXT: TemplateTypeParmDecl
+// CHECK-NEXT: CXXRecordDecl
+template <class T> class C {
+  // CHECK-NEXT: FieldDecl
+  T t;
+};
+
+// CHECK-NEXT: CXXRecordDecl
+// CHECK-NEXT: TemplateName
+// CHECK-NEXT: TemplateArgument
+class I : C<int> {};
Index: test/Tooling/clang-diff-basic.cpp
===================================================================
--- test/Tooling/clang-diff-basic.cpp
+++ test/Tooling/clang-diff-basic.cpp
@@ -1,4 +1,4 @@
-// RUN: clang-diff -dump-matches %S/Inputs/clang-diff-basic-src.cpp %s -- | FileCheck %s
+// RUN: clang-diff -dump-matches %S/Inputs/clang-diff-basic-src.cpp %s -- -std=c++11 | FileCheck %s
 
 // CHECK: Match TranslationUnitDecl{{.*}} to TranslationUnitDecl
 // CHECK: Match NamespaceDecl: src{{.*}} to NamespaceDecl: dst
@@ -68,5 +68,18 @@
   F(1, /*b=*/1);
 }
 
+// CHECK: Update TemplateTypeParmDecl: T{{.*}} to Type
+template <class Type, class U = int>
+U visit(Type &t) {
+  int x = t;
+  return U();
+}
+
+void tmp() {
+  long x;
+  // CHECK: Update TemplateArgument: int{{.*}} to long
+  visit<long>(x);
+}
+
 // CHECK: Delete AccessSpecDecl: public
 // CHECK: Delete CXXMethodDecl
Index: test/Tooling/clang-diff-html.test
===================================================================
--- test/Tooling/clang-diff-html.test
+++ test/Tooling/clang-diff-html.test
@@ -1,4 +1,4 @@
-RUN: clang-diff -html %S/Inputs/clang-diff-basic-src.cpp %S/clang-diff-basic.cpp -- | FileCheck %s
+RUN: clang-diff -html %S/Inputs/clang-diff-basic-src.cpp %S/clang-diff-basic.cpp -- -std=c++11 | FileCheck %s
 
 CHECK: <pre><div id='L' class='code'><span id='L0' tid='R0' title='TranslationUnitDecl
 CHECK-NEXT: 0 -> 0'>