3 files changed, 144 insertions, 9 deletions
diff --git a/include/llvm/Testing/Support/Annotations.h b/include/llvm/Testing/Support/Annotations.h
new file mode 100644
index 000000000000..aad1a44f4ec9
--- /dev/null
+++ b/include/llvm/Testing/Support/Annotations.h
@@ -0,0 +1,90 @@
+//===--- Annotations.h - Annotated source code for tests ---------*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TESTING_SUPPORT_ANNOTATIONS_H
+#define LLVM_TESTING_SUPPORT_ANNOTATIONS_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include <tuple>
+#include <vector>
+
+namespace llvm {
+
+/// Annotations lets you mark points and ranges inside source code, for tests:
+///
+///    Annotations Example(R"cpp(
+///       int complete() { x.pri^ }         // ^ indicates a point
+///       void err() { [["hello" == 42]]; } // [[this is a range]]
+///       $definition^class Foo{};          // points can be named: "definition"
+///       $fail[[static_assert(false, "")]] // ranges can be named too: "fail"
+///    )cpp");
+///
+///    StringRef Code = Example.code();             // annotations stripped.
+///    std::vector<size_t> PP = Example.points();   // all unnamed points
+///    size_t P = Example.point();                  // there must be exactly one
+///    llvm::Range R = Example.range("fail");       // find named ranges
+///
+/// Points/ranges are coordinated into `code()` which is stripped of
+/// annotations.
+///
+/// Ranges may be nested (and points can be inside ranges), but there's no way
+/// to define general overlapping ranges.
+///
+/// FIXME: the choice of the marking syntax makes it impossible to represent
+///        some of the C++ and Objective C constructs (including common ones
+///        like C++ attributes). We can fix this by:
+///          1. introducing an escaping mechanism for the special characters,
+///          2. making characters for marking points and ranges configurable,
+///          3. changing the syntax to something less commonly used,
+///          4. ...
+class Annotations {
+public:
+  /// Two offsets pointing to a continuous substring. End is not included, i.e.
+  /// represents a half-open range.
+  struct Range {
+    size_t Begin = 0;
+    size_t End = 0;
+
+    friend bool operator==(const Range &L, const Range &R) {
+      return std::tie(L.Begin, L.End) == std::tie(R.Begin, R.End);
+    }
+    friend bool operator!=(const Range &L, const Range &R) { return !(L == R); }
+  };
+
+  /// Parses the annotations from Text. Crashes if it's malformed.
+  Annotations(llvm::StringRef Text);
+
+  /// The input text with all annotations stripped.
+  /// All points and ranges are relative to this stripped text.
+  llvm::StringRef code() const { return Code; }
+
+  /// Returns the position of the point marked by ^ (or $name^) in the text.
+  /// Crashes if there isn't exactly one.
+  size_t point(llvm::StringRef Name = "") const;
+  /// Returns the position of all points marked by ^ (or $name^) in the text.
+  std::vector<size_t> points(llvm::StringRef Name = "") const;
+
+  /// Returns the location of the range marked by [[ ]] (or $name[[ ]]).
+  /// Crashes if there isn't exactly one.
+  Range range(llvm::StringRef Name = "") const;
+  /// Returns the location of all ranges marked by [[ ]] (or $name[[ ]]).
+  std::vector<Range> ranges(llvm::StringRef Name = "") const;
+
+private:
+  std::string Code;
+  llvm::StringMap<llvm::SmallVector<size_t, 1>> Points;
+  llvm::StringMap<llvm::SmallVector<Range, 1>> Ranges;
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
+                              const llvm::Annotations::Range &R);
+
+} // namespace llvm
+
+#endif
diff --git a/include/llvm/Testing/Support/Error.h b/include/llvm/Testing/Support/Error.h
index 0e5b5403ce87..85328f26440b 100644
--- a/include/llvm/Testing/Support/Error.h
+++ b/include/llvm/Testing/Support/Error.h
@@ -1,9 +1,8 @@
 //===- llvm/Testing/Support/Error.h ---------------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/include/llvm/Testing/Support/SupportHelpers.h b/include/llvm/Testing/Support/SupportHelpers.h
index b2975ec395d5..38726b1cfaf7 100644
--- a/include/llvm/Testing/Support/SupportHelpers.h
+++ b/include/llvm/Testing/Support/SupportHelpers.h
@@ -1,18 +1,19 @@
 //===- Testing/Support/SupportHelpers.h -----------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H
 #define LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_os_ostream.h"
+#include "gmock/gmock-matchers.h"
 #include "gtest/gtest-printers.h"
 
 #include <string>
@@ -54,11 +55,56 @@ void PrintTo(const ExpectedHolder<T> &Item, std::ostream *Out) {
     PrintTo(static_cast<const ErrorHolder &>(Item), Out);
   }
 }
+
+template <class InnerMatcher> class ValueIsMatcher {
+public:
+  explicit ValueIsMatcher(InnerMatcher ValueMatcher)
+      : ValueMatcher(ValueMatcher) {}
+
+  template <class T>
+  operator ::testing::Matcher<const llvm::Optional<T> &>() const {
+    return ::testing::MakeMatcher(
+        new Impl<T>(::testing::SafeMatcherCast<T>(ValueMatcher)));
+  }
+
+  template <class T>
+  class Impl : public ::testing::MatcherInterface<const llvm::Optional<T> &> {
+  public:
+    explicit Impl(const ::testing::Matcher<T> &ValueMatcher)
+        : ValueMatcher(ValueMatcher) {}
+
+    bool MatchAndExplain(const llvm::Optional<T> &Input,
+                         testing::MatchResultListener *L) const override {
+      return Input && ValueMatcher.MatchAndExplain(Input.getValue(), L);
+    }
+
+    void DescribeTo(std::ostream *OS) const override {
+      *OS << "has a value that ";
+      ValueMatcher.DescribeTo(OS);
+    }
+    void DescribeNegationTo(std::ostream *OS) const override {
+      *OS << "does not have a value that ";
+      ValueMatcher.DescribeTo(OS);
+    }
+
+  private:
+    testing::Matcher<T> ValueMatcher;
+  };
+
+private:
+  InnerMatcher ValueMatcher;
+};
 } // namespace detail
 
+/// Matches an llvm::Optional<T> with a value that conforms to an inner matcher.
+/// To match llvm::None you could use Eq(llvm::None).
+template <class InnerMatcher>
+detail::ValueIsMatcher<InnerMatcher> ValueIs(const InnerMatcher &ValueMatcher) {
+  return detail::ValueIsMatcher<InnerMatcher>(ValueMatcher);
+}
 namespace unittest {
 SmallString<128> getInputFileDirectory(const char *Argv0);
-}
+} // namespace unittest
 } // namespace llvm
 
 #endif