Index: unittests/AST/CMakeLists.txt
===================================================================
--- unittests/AST/CMakeLists.txt
+++ unittests/AST/CMakeLists.txt
@@ -2,6 +2,7 @@
   CommentLexer.cpp
   CommentParser.cpp
   DeclPrinterTest.cpp
+  SourceLocationTest.cpp
   StmtPrinterTest.cpp
   )
 
Index: unittests/AST/SourceLocationTest.cpp
===================================================================
--- /dev/null
+++ unittests/AST/SourceLocationTest.cpp
@@ -0,0 +1,237 @@
+//===- unittest/AST/SourceLocationTest.cpp - AST source loc unit tests ----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace ast_matchers {
+
+using clang::tooling::newFrontendActionFactory;
+using clang::tooling::runToolOnCodeWithArgs;
+using clang::tooling::FrontendActionFactory;
+
+enum Language { Lang_C, Lang_CXX };
+
+/// \brief Base class for verifying some property of nodes found by a matcher.
+template <typename NodeType>
+class MatchVerifier : public MatchFinder::MatchCallback {
+public:
+  template <typename MatcherType>
+  testing::AssertionResult match(const std::string &Code,
+                                 const MatcherType &AMatcher) {
+    return match(Code, AMatcher, Lang_CXX);
+  }
+
+  template <typename MatcherType>
+  testing::AssertionResult match(const std::string &Code,
+                                 const MatcherType &AMatcher, Language L);
+
+  virtual void run(const MatchFinder::MatchResult &Result);
+
+protected:
+  virtual void verify(const MatchFinder::MatchResult &Result,
+                      const NodeType &Node) = 0;
+
+  void setFailure(const Twine &Result) {
+    Verified = false;
+    VerifyResult = Result.str();
+  }
+
+private:
+  bool Verified;
+  std::string VerifyResult;
+};
+
+/// \brief Runs a matcher over some code, and returns the result of the
+/// verifier for the matched node.
+template <typename NodeType> template <typename MatcherType>
+testing::AssertionResult MatchVerifier<NodeType>::match(
+    const std::string &Code, const MatcherType &AMatcher, Language L) {
+  MatchFinder Finder;
+  Finder.addMatcher(AMatcher.bind(""), this);
+  OwningPtr<FrontendActionFactory> Factory(newFrontendActionFactory(&Finder));
+
+  std::vector<std::string> Args;
+  StringRef FileName;
+  switch (L) {
+  case Lang_C:
+    Args.push_back("-std=c99");
+    FileName = "input.c";
+    break;
+  case Lang_CXX:
+    Args.push_back("-std=c++98");
+    FileName = "input.cc";
+    break;
+  }
+
+  // Default to failure in case callback is never called
+  setFailure("Could not find match");
+  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
+    return testing::AssertionFailure() << "Parsing error";
+  if (!Verified)
+    return testing::AssertionFailure() << VerifyResult;
+  return testing::AssertionSuccess();
+}
+
+template <typename NodeType>
+void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {
+  const NodeType *Node = Result.Nodes.getNodeAs<NodeType>("");
+  if (!Node) {
+    setFailure("Matched node has wrong type");
+  } else {
+    // Callback has been called, default to success
+    Verified = true;
+    verify(Result, *Node);
+  }
+}
+
+/// \brief Verify whether a node has the correct source location.
+///
+/// By default, Node.getSourceLocation() is checked. This can be changed
+/// by overriding getLocation().
+template <typename NodeType>
+class LocationVerifier : public MatchVerifier<NodeType> {
+public:
+  void expectLocation(unsigned Line, unsigned Column) {
+    ExpectLine = Line;
+    ExpectColumn = Column;
+  }
+
+protected:
+  void verify(const MatchFinder::MatchResult &Result, const NodeType &Node) {
+    SourceLocation Loc = getLocation(Node);
+    FullSourceLoc FullLoc = Result.Context->getFullLoc(Loc);
+    unsigned Line = FullLoc.getSpellingLineNumber();
+    unsigned Column = FullLoc.getSpellingColumnNumber();
+    if (Line != ExpectLine || Column != ExpectColumn) {
+      this->setFailure(
+          "Expected location <" +
+          Twine(ExpectLine) + ":" + Twine(ExpectColumn) + ">, found <" +
+          Twine(Line) + ":" + Twine(Column) + ">");
+    }
+  }
+
+  virtual SourceLocation getLocation(const NodeType &Node) {
+    return Node.getLocation();
+  }
+
+private:
+  unsigned ExpectLine, ExpectColumn;
+};
+
+/// \brief Verify whether a node has the correct source range.
+///
+/// By default, Node.getSourceRange() is checked. This can be changed
+/// by overriding getRange().
+template <typename NodeType>
+class RangeVerifier : public MatchVerifier<NodeType> {
+public:
+  void expectRange(unsigned BeginLine, unsigned BeginColumn,
+                   unsigned EndLine, unsigned EndColumn) {
+    ExpectBeginLine = BeginLine;
+    ExpectBeginColumn = BeginColumn;
+    ExpectEndLine = EndLine;
+    ExpectEndColumn = EndColumn;
+  }
+
+protected:
+  void verify(const MatchFinder::MatchResult &Result, const NodeType &Node) {
+    SourceRange R = getRange(Node);
+    FullSourceLoc Begin = Result.Context->getFullLoc(R.getBegin());
+    FullSourceLoc End = Result.Context->getFullLoc(R.getEnd());
+    unsigned BeginLine = Begin.getSpellingLineNumber();
+    unsigned BeginColumn = Begin.getSpellingColumnNumber();
+    unsigned EndLine = End.getSpellingLineNumber();
+    unsigned EndColumn = End.getSpellingColumnNumber();
+    if (BeginLine != ExpectBeginLine || BeginColumn != ExpectBeginColumn ||
+        EndLine != ExpectEndLine || EndColumn != ExpectEndColumn) {
+      this->setFailure(
+          "Expected range <" +
+          Twine(ExpectBeginLine) + ":" + Twine(ExpectBeginColumn) + ", " +
+          Twine(ExpectEndLine) + ":" + Twine(ExpectEndColumn) + ">, found <" +
+          Twine(BeginLine) + ":" + Twine(BeginColumn) + ", " +
+          Twine(EndLine) + ":" + Twine(EndColumn) + ">");
+    }
+  }
+
+  virtual SourceRange getRange(const NodeType &Node) {
+    return Node.getSourceRange();
+  }
+
+private:
+  unsigned ExpectBeginLine, ExpectBeginColumn, ExpectEndLine, ExpectEndColumn;
+};
+
+TEST(MatchVerifier, ParseError) {
+  LocationVerifier<VarDecl> Verifier;
+  Verifier.expectLocation(1, 1);
+  EXPECT_FALSE(Verifier.match("int i", varDecl()));
+}
+
+TEST(MatchVerifier, NoMatch) {
+  LocationVerifier<VarDecl> Verifier;
+  Verifier.expectLocation(1, 1);
+  EXPECT_FALSE(Verifier.match("int i;", recordDecl()));
+}
+
+TEST(MatchVerifier, WrongType) {
+  LocationVerifier<RecordDecl> Verifier;
+  Verifier.expectLocation(1, 1);
+  EXPECT_FALSE(Verifier.match("int i;", varDecl()));
+}
+
+TEST(LocationVerifier, WrongLocation) {
+  LocationVerifier<VarDecl> Verifier;
+  Verifier.expectLocation(1, 1);
+  EXPECT_FALSE(Verifier.match("int i;", varDecl()));
+}
+
+TEST(RangeVerifier, WrongRange) {
+  RangeVerifier<VarDecl> Verifier;
+  Verifier.expectRange(1, 1, 1, 1);
+  EXPECT_FALSE(Verifier.match("int i;", varDecl()));
+}
+
+class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> {
+protected:
+  virtual SourceRange getRange(const LabelStmt &Node) {
+    return Node.getDecl()->getSourceRange();
+  }
+};
+
+TEST(LabelDecl, Range) {
+  LabelDeclRangeVerifier Verifier;
+  Verifier.expectRange(1, 12, 1, 12);
+  EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
+}
+
+TEST(LabelStmt, Range) {
+  RangeVerifier<LabelStmt> Verifier;
+  Verifier.expectRange(1, 12, 1, 15);
+  EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
+}
+
+TEST(ParmVarDecl, KNRLocation) {
+  LocationVerifier<ParmVarDecl> Verifier;
+  Verifier.expectLocation(1, 8);
+  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
+}
+
+TEST(ParmVarDecl, KNRRange) {
+  RangeVerifier<ParmVarDecl> Verifier;
+  Verifier.expectRange(1, 8, 1, 8);
+  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
+}
+
+} // end namespace ast_matchers
+} // end namespace clang