HomeSort by: relevance | last modified time | path
    Searched defs:Matcher (Results 1 - 17 of 17) sorted by relevancy

  /src/external/apache2/llvm/dist/llvm/utils/unittest/googletest/src/
gtest-matchers.cc 32 // This file implements just enough of the matcher interface to allow
33 // EXPECT_DEATH and friends to accept a matcher argument.
43 // Constructs a matcher that matches a const std::string& whose value is
45 Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }
47 // Constructs a matcher that matches a const std::string& whose value is
49 Matcher<const std::string&>::Matcher(const char* s) {
53 // Constructs a matcher that matches a std::string whose value is equal to
55 Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s);
    [all...]
  /src/external/apache2/llvm/dist/llvm/include/llvm/Testing/Support/
Error.h 35 explicit ValueMatchesMono(const testing::Matcher<T> &Matcher)
36 : Matcher(Matcher) {}
43 bool result = Matcher.MatchAndExplain(*Holder.Exp, listener);
48 Matcher.DescribeNegationTo(listener->stream());
55 Matcher.DescribeTo(OS);
61 Matcher.DescribeNegationTo(OS);
66 testing::Matcher<T> Matcher;
    [all...]
SupportHelpers.h 67 operator ::testing::Matcher<const llvm::Optional<T> &>() const {
75 explicit Impl(const ::testing::Matcher<T> &ValueMatcher)
93 testing::Matcher<T> ValueMatcher;
101 /// Matches an llvm::Optional<T> with a value that conforms to an inner matcher.
  /src/external/apache2/llvm/dist/llvm/include/llvm/Support/
SpecialCaseList.h 121 class Matcher {
134 using SectionEntries = StringMap<StringMap<Matcher>>;
137 Section(std::unique_ptr<Matcher> M) : SectionMatcher(std::move(M)){};
139 std::unique_ptr<Matcher> SectionMatcher;
  /src/external/apache2/llvm/dist/llvm/utils/unittest/googletest/include/gtest/
gtest-matchers.h 32 // This file implements just enough of the matcher interface to allow
33 // EXPECT_DEATH and friends to accept a matcher argument.
65 // To implement a matcher Foo for type T, define:
68 // 2. a factory function that creates a Matcher<T> object from a
72 // to write "v" instead of "Eq(v)" where a Matcher is expected, which
74 // ownership management as Matcher objects can now be copied like
78 // used by a matcher to explain why a value matches or doesn't match.
100 // of the match result. A matcher's MatchAndExplain() method can use
115 // matcher.
120 // Describes this matcher to an ostream. The function should prin
    [all...]
  /src/external/apache2/llvm/dist/llvm/utils/unittest/googlemock/include/gmock/
gmock-matchers.h 38 // Matcher, class MatcherInterface, and others.
84 // To implement a matcher Foo for type T, define:
87 // 2. a factory function that creates a Matcher<T> object from a
91 // to write "v" instead of "Eq(v)" where a Matcher is expected, which
93 // ownership management as Matcher objects can now be copied like
124 // polymorphic matcher (i.e. something that can be converted to a
125 // Matcher but is not one yet; for example, Eq(value)) or a value (for
130 static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
131 // M can be a polymorphic matcher, in which case we want to use
132 // its conversion operator to create Matcher<T>. Or it can be a valu
392 typename std::tuple_element<N - 1, MatcherTuple>::type matcher = local
1322 const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_); local
    [all...]
  /src/external/apache2/llvm/dist/clang/include/clang/Tooling/Transformer/
RewriteRule.h 99 // Or, if you are changing the node corresponding to the rule's matcher, you can
260 // * Matcher: the pattern term, expressed as clang matchers (with Transformer
280 ast_matchers::internal::DynTypedMatcher Matcher;
327 // `applyFirst` is like an `anyOf` matcher with an edit action attached to each
422 /// Builds a single matcher for the rule, covering all of the rule's cases.
430 /// One matcher is built for each distinct node matcher base kind: Stmt, Decl,
445 /// Assumes a matcher built with \c buildMatcher.
  /src/external/apache2/llvm/dist/clang/include/clang/ASTMatchers/
ASTMatchersInternal.h 9 // Implements the base layer of the matcher framework.
11 // Matchers are methods that return a Matcher<T> which provides a method
18 // 1. A function Matcher<T> MatcherName(<arguments>) which returns a Matcher<T>
20 // on the arguments. Matcher<T>s form an implicit reverse hierarchy
21 // to clang's AST class hierarchy, meaning that you can use a Matcher<Base>
22 // everywhere a Matcher<Derived> is required.
25 // The matcher functions are defined in ASTMatchers.h. To make it possible
26 // to implement both the matcher function and the implementation of the matcher
    [all...]
  /src/external/apache2/llvm/dist/clang/include/clang/ASTMatchers/Dynamic/
VariantValue.h 12 /// Supports all the types required for dynamic Matcher construction.
44 /// Constructor for non-matcher types.
47 /// Constructor for matcher types.
92 /// A variant matcher object.
97 /// overloads of the matcher. \c VariantMatcher knows how to select the
99 /// To get a real matcher object out of a \c VariantMatcher you can do:
100 /// - getSingleMatcher() which returns a matcher, only if it is not ambiguous
101 /// to decide which matcher to return. Eg. it contains only a single
102 /// matcher, or a polymorphic one with only one overload.
104 /// the underlying matcher(s) can unambiguously return a Matcher<T>
    [all...]
  /src/external/apache2/llvm/dist/clang/lib/ASTMatchers/Dynamic/
Registry.cpp 1 //===- Registry.cpp - Matcher registry ------------------------------------===//
632 // Starting with the above seed of acceptable top-level matcher types, compute
660 const MatcherDescriptor& Matcher = *M.getValue();
664 unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs();
665 bool IsPolymorphic = Matcher.isPolymorphic();
679 if (Matcher.isConvertibleTo(Kind.getNodeKind(), &Specificity,
685 Matcher.getArgKinds(Kind.getNodeKind(), Arg, ArgsKinds[Arg]);
692 if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity,
698 Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg])
    [all...]
VariantValue.cpp 25 return (Twine("Matcher<") + NodeKind.asStringRef() + ">").str();
58 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
60 IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
61 return Matcher.canConvertTo(NodeKind);
65 const DynTypedMatcher &Matcher) const {
66 return Matcher.dynCastTo(NodeKind);
76 // Matcher<T>.
92 SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
    [all...]
  /src/external/apache2/llvm/dist/llvm/utils/TableGen/
DAGISelMatcherEmitter.cpp 1 //===- DAGISelMatcherEmitter.cpp - Matcher Emitter ------------------------===//
9 // This file contains code to generate C++ code for a matcher.
51 SmallVector<unsigned, Matcher::HighestKind+1> OpcodeCounts;
86 OpcodeCounts.assign(Matcher::HighestKind+1, 0);
89 unsigned EmitMatcherList(const Matcher *N, const unsigned Indent,
92 unsigned SizeMatcherList(Matcher *N, raw_ostream &OS);
96 void EmitHistogram(const Matcher *N, raw_ostream &OS);
104 unsigned SizeMatcher(Matcher *N, raw_ostream &OS);
106 unsigned EmitMatcher(const Matcher *N, const unsigned Indent, unsigned CurrentIdx,
242 /// This function traverses the matcher tree and sizes all the node
    [all...]
GICombinerEmitter.cpp 93 /// The name of the variable as declared in the generated matcher.
122 const DagInit *Matcher;
126 const DagInit *Matcher)
127 : N(N), Op(Op), Matcher(Matcher) {}
226 /// The matcher will begin from the roots and will perform the match by
365 // generated matcher has a suitable variable for it to do so.
395 // Parse an (Instruction $a:Arg1, $b:Arg2, ...) matcher. Edges are formed
401 if (const DagInit *Matcher =
404 Target.getInstruction(Matcher->getOperatorAsDef(TheDef.getLoc()))
    [all...]
DAGISelMatcher.h 1 //===- DAGISelMatcher.h - Representation of DAG pattern matcher -*- C++ -*-===//
21 class Matcher;
30 Matcher *ConvertPatternToMatcher(const PatternToMatch &Pattern,unsigned Variant,
32 void OptimizeMatcher(std::unique_ptr<Matcher> &Matcher,
34 void EmitMatcherTable(Matcher *Matcher, const CodeGenDAGPatterns &CGP,
38 /// Matcher - Base class for all the DAG ISel Matcher representation
40 class Matcher {
    [all...]
GlobalISelEmitter.cpp 482 class Matcher;
552 static MatchTable buildTable(ArrayRef<Matcher *> Rules, bool WithCoverage);
660 class Matcher {
662 virtual ~Matcher() = default;
671 MatchTable MatchTable::buildTable(ArrayRef<Matcher *> Rules,
674 for (Matcher *Rule : Rules)
680 class GroupMatcher final : public Matcher {
685 std::vector<Matcher *> Matchers;
689 std::vector<std::unique_ptr<Matcher>> MatcherStorage;
692 /// Add a matcher to the collection of nested matchers if it meets th
    [all...]
  /src/external/apache2/llvm/dist/clang/include/clang/Analysis/Analyses/
ThreadSafetyTraverse.h 394 MatchComparator Matcher;
395 return Matcher.compare(E1, E2);
  /src/external/apache2/llvm/dist/clang/lib/ASTMatchers/
ASTMatchFinder.cpp 13 // calling the Matches(...) method of each matcher we are running on each
14 // AST node. The matcher can recurse via the ASTMatchFinder interface.
38 // of performance vs. memory consumption by running matcher
53 // We use memoization to avoid running the same matcher on the same
56 // identifying the matcher), a pointer to the AST node and the
57 // bound nodes before the matcher was executed.
92 // Creates an AST visitor that matches 'matcher' on all children or
96 MatchChildASTVisitor(const DynTypedMatcher *Matcher, ASTMatchFinder *Finder,
100 : Matcher(Matcher), Finder(Finder), Builder(Builder), CurrentDepth(0)
    [all...]

Completed in 41 milliseconds