177 lines
6.8 KiB
C++
177 lines
6.8 KiB
C++
//===--- 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 {
|
|
|
|
class raw_ostream;
|
|
|
|
/// 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"
|
|
/// $(foo)^class Foo{}; // ...or have a payload: "foo"
|
|
/// $definition(foo)^class Foo{}; // ...or both
|
|
/// $fail(runtime)[[assert(false)]] // ranges can have names/payloads
|
|
/// // too
|
|
/// )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.
|
|
///
|
|
/// Names consist of only alphanumeric characters or '_'.
|
|
/// Payloads can contain any character expect '(' and ')'.
|
|
///
|
|
/// Ranges may be nested (and points can be inside ranges), but there's no way
|
|
/// to define general overlapping ranges.
|
|
///
|
|
/// The markers for points, names and ranges can be customized. This is useful
|
|
/// when the default markers would otherwise conflict with the underlying syntax
|
|
/// (e.g. C++ attributes or the reflection operator). For example, to use "~" as
|
|
/// the point marker, "@@" as the name/payload marker, and "{{" / "}}" as range
|
|
/// delimiters:
|
|
///
|
|
/// Annotations Example("~point @@name{{range}}", {"~", "@@", "{{", "}}"});
|
|
///
|
|
/// Alternatively, use setters to customize markers individually:
|
|
///
|
|
/// // Customize only the point marker, leaving the rest as default:
|
|
/// Annotations Example("~point $name[[range]]", Annotations::Markers()
|
|
/// .setPoint("~"));
|
|
///
|
|
/// // Customize all markers:
|
|
/// Annotations Example("~point @@name{{range}}", Annotations::Markers()
|
|
/// .setPoint("~")
|
|
/// .setName("@@")
|
|
/// .setRangeBegin("{{")
|
|
/// .setRangeEnd("}}"));
|
|
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); }
|
|
};
|
|
|
|
/// Markers used to denote points, names/payloads and ranges in the annotated
|
|
/// text.
|
|
struct Markers {
|
|
llvm::StringRef Point = "^";
|
|
llvm::StringRef Name = "$";
|
|
llvm::StringRef RangeBegin = "[[";
|
|
llvm::StringRef RangeEnd = "]]";
|
|
|
|
Markers &setPoint(llvm::StringRef P) {
|
|
Point = P;
|
|
return *this;
|
|
}
|
|
Markers &setName(llvm::StringRef N) {
|
|
Name = N;
|
|
return *this;
|
|
}
|
|
Markers &setRangeBegin(llvm::StringRef B) {
|
|
RangeBegin = B;
|
|
return *this;
|
|
}
|
|
Markers &setRangeEnd(llvm::StringRef E) {
|
|
RangeEnd = E;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/// Parses the annotations from Text. Crashes if it's malformed.
|
|
Annotations(llvm::StringRef Text);
|
|
/// Parses the annotations from Text using custom markers.
|
|
/// Markers must be non-empty and unambiguous.
|
|
Annotations(llvm::StringRef Text, const Markers &Markers);
|
|
|
|
/// 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 the point with \p Name and its payload (if any).
|
|
std::pair<size_t, llvm::StringRef>
|
|
pointWithPayload(llvm::StringRef Name = "") const;
|
|
/// Returns the position of all points marked by ^ (or $name^) in the text.
|
|
/// Order matches the order within the text.
|
|
std::vector<size_t> points(llvm::StringRef Name = "") const;
|
|
/// Returns the positions and payloads (if any) of all points named \p Name
|
|
std::vector<std::pair<size_t, llvm::StringRef>>
|
|
pointsWithPayload(llvm::StringRef Name = "") const;
|
|
/// Returns the mapping of all names of points marked in the text to their
|
|
/// position. Unnamed points are mapped to the empty string. The positions are
|
|
/// sorted.
|
|
/// FIXME Remove this and expose `All` directly (currently used out-of-tree)
|
|
llvm::StringMap<llvm::SmallVector<size_t, 1>> all_points() 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 and payload of the range marked by [[ ]]
|
|
/// (or $name(payload)[[ ]]). Crashes if there isn't exactly one.
|
|
std::pair<Range, llvm::StringRef>
|
|
rangeWithPayload(llvm::StringRef Name = "") const;
|
|
/// Returns the location of all ranges marked by [[ ]] (or $name[[ ]]).
|
|
/// They are ordered by start position within the text.
|
|
std::vector<Range> ranges(llvm::StringRef Name = "") const;
|
|
/// Returns the location of all ranges marked by [[ ]]
|
|
/// (or $name(payload)[[ ]]).
|
|
/// They are ordered by start position within the text.
|
|
std::vector<std::pair<Range, llvm::StringRef>>
|
|
rangesWithPayload(llvm::StringRef Name = "") const;
|
|
/// Returns the mapping of all names of ranges marked in the text to their
|
|
/// location. Unnamed ranges are mapped to the empty string. The ranges are
|
|
/// sorted by their start position.
|
|
llvm::StringMap<llvm::SmallVector<Range, 1>> all_ranges() const;
|
|
|
|
private:
|
|
std::string Code;
|
|
/// Either a Point (Only Start) or a Range (Start and End)
|
|
struct Annotation {
|
|
size_t Begin;
|
|
size_t End = -1;
|
|
bool isPoint() const { return End == size_t(-1); }
|
|
llvm::StringRef Name;
|
|
llvm::StringRef Payload;
|
|
};
|
|
std::vector<Annotation> All;
|
|
// Values are the indices into All
|
|
llvm::StringMap<llvm::SmallVector<size_t, 1>> Points;
|
|
llvm::StringMap<llvm::SmallVector<size_t, 1>> Ranges;
|
|
};
|
|
|
|
llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
|
|
const llvm::Annotations::Range &R);
|
|
|
|
} // namespace llvm
|
|
|
|
#endif
|