maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/ASTMatchers/Dynamic/Registry.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

694 lines
24 KiB
C++
Raw Normal View History

[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
//===- Registry.cpp - Matcher registry ------------------------------------===//
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// 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
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
//
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
//===----------------------------------------------------------------------===//
//
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
/// \file
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Registry map populated at static initialization time.
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
//
//===----------------------------------------------------------------------===//
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
#include "clang/ASTMatchers/Dynamic/Registry.h"
#include "Marshallers.h"
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
#include "clang/AST/ASTTypeTraits.h"
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
#include "clang/ASTMatchers/ASTMatchers.h"
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
#include "clang/ASTMatchers/Dynamic/Diagnostics.h"
#include "clang/ASTMatchers/Dynamic/VariantValue.h"
#include "llvm/ADT/Optional.h"
Switching from an explicit loop to DeleteContainerSeconds; NFC. llvm-svn: 244802
2015-08-13 04:05:18 +08:00
#include "llvm/ADT/STLExtras.h"
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ManagedStatic.h"
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <iterator>
#include <memory>
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
#include <set>
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
#include <string>
Sort all the #include lines with LLVM's utils/sort_includes.py which encodes the canonical rules for LLVM's style. I noticed this had drifted quite a bit when cleaning up LLVM, so wanted to clean up Clang as well. llvm-svn: 198686
2014-01-07 19:51:46 +08:00
#include <utility>
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
#include <vector>
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
using namespace clang::ast_type_traits;
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
namespace clang {
namespace ast_matchers {
namespace dynamic {
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
namespace {
Rename *MatcherCreateCallback to *MatcherDescriptor, and its member run() to create(). The new names will be more appropriate when the objects are taught to return type information for the code completer. Differential Revision: http://llvm-reviews.chandlerc.com/D2208 llvm-svn: 195539
2013-11-23 09:34:36 +08:00
using internal::MatcherDescriptor;
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
using ConstructorMap = llvm::StringMap<std::unique_ptr<const MatcherDescriptor>>;
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
class RegistryMaps {
public:
RegistryMaps();
~RegistryMaps();
const ConstructorMap &constructors() const { return Constructors; }
private:
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
void registerMatcher(StringRef MatcherName,
std::unique_ptr<MatcherDescriptor> Callback);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
ConstructorMap Constructors;
};
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
} // namespace
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
void RegistryMaps::registerMatcher(
StringRef MatcherName, std::unique_ptr<MatcherDescriptor> Callback) {
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
assert(Constructors.find(MatcherName) == Constructors.end());
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
Constructors[MatcherName] = std::move(Callback);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
}
#define REGISTER_MATCHER(name) \
registerMatcher(#name, internal::makeMatcherAutoMarshall( \
::clang::ast_matchers::name, #name));
[ASTMatchers] Add clang-query support for equals matcher Summary: This allows the clang-query tool to use matchers like "integerLiteral(equals(32))". For this to work, an overloaded function is added for each possible parameter type. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D33094 llvm-svn: 305022
2017-06-09 06:00:58 +08:00
#define REGISTER_MATCHER_OVERLOAD(name) \
registerMatcher(#name, \
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
std::make_unique<internal::OverloadedMatcherDescriptor>(name##Callbacks))
[ASTMatchers] Add clang-query support for equals matcher Summary: This allows the clang-query tool to use matchers like "integerLiteral(equals(32))". For this to work, an overloaded function is added for each possible parameter type. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D33094 llvm-svn: 305022
2017-06-09 06:00:58 +08:00
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
#define SPECIFIC_MATCHER_OVERLOAD(name, Id) \
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
static_cast<::clang::ast_matchers::name##_Type##Id>( \
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
::clang::ast_matchers::name)
[ASTMatchers] Add clang-query support for equals matcher Summary: This allows the clang-query tool to use matchers like "integerLiteral(equals(32))". For this to work, an overloaded function is added for each possible parameter type. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D33094 llvm-svn: 305022
2017-06-09 06:00:58 +08:00
#define MATCHER_OVERLOAD_ENTRY(name, Id) \
internal::makeMatcherAutoMarshall(SPECIFIC_MATCHER_OVERLOAD(name, Id), \
#name)
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
#define REGISTER_OVERLOADED_2(name) \
do { \
[ASTMatchers] Add clang-query support for equals matcher Summary: This allows the clang-query tool to use matchers like "integerLiteral(equals(32))". For this to work, an overloaded function is added for each possible parameter type. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D33094 llvm-svn: 305022
2017-06-09 06:00:58 +08:00
std::unique_ptr<MatcherDescriptor> name##Callbacks[] = { \
MATCHER_OVERLOAD_ENTRY(name, 0), \
MATCHER_OVERLOAD_ENTRY(name, 1)}; \
REGISTER_MATCHER_OVERLOAD(name); \
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
} while (false)
Add support for Adaptative matchers on the dynamic registry. Summary: Add support for Adaptative matchers on the dynamic registry. Each adaptative matcher is created with a function template. We instantiate the function N times, one for each possible From type and apply the techniques used on argument overloaded and polymorphic matchers to add them to the registry. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1201 llvm-svn: 187044
2013-07-24 22:48:01 +08:00
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Generate a registry map with all the known matchers.
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
/// Please keep sorted alphabetically!
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
RegistryMaps::RegistryMaps() {
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
// TODO: Here is the list of the missing matchers, grouped by reason.
//
// Need Variant/Parser fixes:
// ofKind
//
// Polymorphic + argument overload:
// findAll
//
// Other:
// equalsNode
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
REGISTER_OVERLOADED_2(callee);
REGISTER_OVERLOADED_2(hasPrefix);
REGISTER_OVERLOADED_2(hasType);
[ASTMatchers] overload ignoringParens for Expr Summary: This patch allows fixing PR39583. Reviewers: aaron.ballman, sbenza, klimek Reviewed By: aaron.ballman Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D54307 llvm-svn: 346554
2018-11-10 04:54:06 +08:00
REGISTER_OVERLOADED_2(ignoringParens);
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
REGISTER_OVERLOADED_2(isDerivedFrom);
[clang] Add isDirectlyDerivedFrom AST matcher. Differential Revision: https://reviews.llvm.org/D65092 llvm-svn: 367010
2019-07-25 19:54:13 +08:00
REGISTER_OVERLOADED_2(isDirectlyDerivedFrom);
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
REGISTER_OVERLOADED_2(isSameOrDerivedFrom);
Add loc() to the dynamic registry. Summary: Add loc() to the dynamic registry. Other fixes: - Fix the polymorphic variant value to accept an exact match, even if there are other possible conversions. - Fix specifiesTypeLoc() to not crash on an empty NestedNameSpecifierLoc. Reviewers: klimek CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2928 llvm-svn: 203467
2014-03-10 23:40:23 +08:00
REGISTER_OVERLOADED_2(loc);
Add support for overloaded matchers. ie different matcher function signatures with the same name. Summary: Add support for overloaded matchers. This composes with other features, like supporting polymorphic matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1188 llvm-svn: 186836
2013-07-23 00:13:57 +08:00
REGISTER_OVERLOADED_2(pointsTo);
REGISTER_OVERLOADED_2(references);
REGISTER_OVERLOADED_2(thisPointerType);
[ASTMatchers] Add clang-query support for equals matcher Summary: This allows the clang-query tool to use matchers like "integerLiteral(equals(32))". For this to work, an overloaded function is added for each possible parameter type. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D33094 llvm-svn: 305022
2017-06-09 06:00:58 +08:00
std::unique_ptr<MatcherDescriptor> equalsCallbacks[] = {
MATCHER_OVERLOAD_ENTRY(equals, 0),
MATCHER_OVERLOAD_ENTRY(equals, 1),
MATCHER_OVERLOAD_ENTRY(equals, 2),
};
REGISTER_MATCHER_OVERLOAD(equals);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(accessSpecDecl);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(addrLabelExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(alignOfExpr);
Add support for eachOf/allOf/anyOf variadic matchers in the dynamic layer. Summary: Add support for eachOf/allOf/anyOf variadic matchers in the dynamic layer. These function require some late binding behavior for the type conversions, thus changes in VariadicValue's MatcherList. Second try. This time with a fix for C++11 builds. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1536 llvm-svn: 189500
2013-08-29 02:42:04 +08:00
REGISTER_MATCHER(allOf);
REGISTER_MATCHER(anyOf);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(anything);
REGISTER_MATCHER(argumentCountIs);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(arraySubscriptExpr);
REGISTER_MATCHER(arrayType);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(asString);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(asmStmt);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(atomicExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(atomicType);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(autoType);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(autoreleasePoolStmt)
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(binaryConditionalOperator);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(binaryOperator);
[ASTMatchers] Introduce a blockDecl matcher for matching block declarations Blocks can be matched just as well as functions or Objective-C methods. Differential Revision: https://reviews.llvm.org/D46980 llvm-svn: 332545
2018-05-17 06:47:03 +08:00
REGISTER_MATCHER(blockDecl);
[clang] Add AST matcher for block expressions 🔍 Summary: This change adds a new AST matcher for block expressions. Test Notes: Ran the clang unit tests. Reviewers: aaron.ballman Reviewed By: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55546 llvm-svn: 349004
2018-12-13 11:35:10 +08:00
REGISTER_MATCHER(blockExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(blockPointerType);
[ASTMatchers] Add booleanType() matcher. llvm-svn: 256278
2015-12-23 04:06:40 +08:00
REGISTER_MATCHER(booleanType);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(breakStmt);
REGISTER_MATCHER(builtinType);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(cStyleCastExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(callExpr);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(caseStmt);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(castExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(characterLiteral);
[ASTImporter] Add support for importing ChooseExpr AST nodes. Summary: This allows ASTs to be merged when they contain ChooseExpr (the GNU __builtin_choose_expr construction). This is needed, for example, for cross-CTU analysis of C code that makes use of __builtin_choose_expr. The node is already supported in the AST, but it didn't have a matcher in ASTMatchers. So, this change adds the matcher and adds support to ASTImporter. This was originally reviewed and approved in https://reviews.llvm.org/D58292 and submitted as r354832. It was reverted in r354839 due to failures on the Windows CI builds. This version fixes the test failures on Windows, which were caused by differences in template expansion between versions of clang on different OSes. The version of clang built with MSVC and running on Windows never expands the template in the C++ test in ImportExpr.ImportChooseExpr in clang/unittests/AST/ASTImporter.cpp, but the version on Linux does for the empty arguments and -fms-compatibility. So, this version of the patch drops the C++ test for __builtin_choose_expr, since that version was written to catch regressions of the logic for isConditionTrue() in the AST import code for ChooseExpr, and those regressions are also caught by ASTImporterOptionSpecificTestBase.ImportChooseExpr, which does work on Windows. Reviewers: shafik, a_sidorin, martong, aaron.ballman, rnk, a.sidorin Subscribers: cfe-commits, jdoerfert, rnkovacs, aaron.ballman Tags: #clang Differential Revision: https://reviews.llvm.org/D58663 llvm-svn: 354916
2019-02-27 03:26:41 +08:00
REGISTER_MATCHER(chooseExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(classTemplateDecl);
REGISTER_MATCHER(classTemplateSpecializationDecl);
REGISTER_MATCHER(complexType);
REGISTER_MATCHER(compoundLiteralExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(compoundStmt);
REGISTER_MATCHER(conditionalOperator);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(constantArrayType);
Compound literals, enums, et al require const expr Summary: Compound literals, enums, file-scoped arrays, etc. require their initializers and size specifiers to be constant. Wrap the initializer expressions in a ConstantExpr so that we can easily check for this later on. Reviewers: rsmith, shafik Reviewed By: rsmith Subscribers: cfe-commits, jyknight, nickdesaulniers Differential Revision: https://reviews.llvm.org/D53921 llvm-svn: 346455
2018-11-09 08:41:36 +08:00
REGISTER_MATCHER(constantExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(containsDeclaration);
REGISTER_MATCHER(continueStmt);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(cudaKernelCallExpr);
REGISTER_MATCHER(cxxBindTemporaryExpr);
REGISTER_MATCHER(cxxBoolLiteral);
REGISTER_MATCHER(cxxCatchStmt);
REGISTER_MATCHER(cxxConstCastExpr);
REGISTER_MATCHER(cxxConstructExpr);
REGISTER_MATCHER(cxxConstructorDecl);
REGISTER_MATCHER(cxxConversionDecl);
REGISTER_MATCHER(cxxCtorInitializer);
[clang] Adapt ASTMatcher to explicit(bool) specifier Summary: Changes: - add an ast matcher for deductiong guide. - allow isExplicit matcher for deductiong guide. - add hasExplicitSpecifier matcher which give access to the expression of the explicit specifier if present. Reviewers: klimek, rsmith, aaron.ballman Reviewed By: aaron.ballman Subscribers: aaron.ballman, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61552 llvm-svn: 363855
2019-06-20 02:27:56 +08:00
REGISTER_MATCHER(cxxDeductionGuideDecl);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(cxxDefaultArgExpr);
REGISTER_MATCHER(cxxDeleteExpr);
[ASTMatchers] Add matchers unresolvedMemberExpr, cxxDependentScopeMemberExpr Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50606 llvm-svn: 339522
2018-08-13 01:34:36 +08:00
REGISTER_MATCHER(cxxDependentScopeMemberExpr);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(cxxDestructorDecl);
REGISTER_MATCHER(cxxDynamicCastExpr);
REGISTER_MATCHER(cxxForRangeStmt);
REGISTER_MATCHER(cxxFunctionalCastExpr);
REGISTER_MATCHER(cxxMemberCallExpr);
REGISTER_MATCHER(cxxMethodDecl);
REGISTER_MATCHER(cxxNewExpr);
REGISTER_MATCHER(cxxNullPtrLiteralExpr);
REGISTER_MATCHER(cxxOperatorCallExpr);
REGISTER_MATCHER(cxxRecordDecl);
REGISTER_MATCHER(cxxReinterpretCastExpr);
REGISTER_MATCHER(cxxStaticCastExpr);
Add cxxStdInitializerListExpr AST matcher Summary: This adds a new ASTMatcher for CXXStdInitializerListExprs that matches C++ initializer list expressions. The primary motivation is to use it to fix [[ https://bugs.llvm.org/show_bug.cgi?id=32896 | PR32896 ]] (review here [[ https://reviews.llvm.org/D32767 | D32767 ]]). Reviewers: alexfh, Prazek, aaron.ballman Reviewed By: alexfh, aaron.ballman Subscribers: malcolm.parsons, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D32810 llvm-svn: 302287
2017-05-06 05:01:12 +08:00
REGISTER_MATCHER(cxxStdInitializerListExpr);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(cxxTemporaryObjectExpr);
REGISTER_MATCHER(cxxThisExpr);
REGISTER_MATCHER(cxxThrowExpr);
REGISTER_MATCHER(cxxTryStmt);
REGISTER_MATCHER(cxxUnresolvedConstructExpr);
Add decayedType and hasDecayedType AST matchers Summary: Add decayedType and hasDecayedType AST matchers Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D13639 llvm-svn: 250114
2015-10-13 05:46:07 +08:00
REGISTER_MATCHER(decayedType);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(decl);
REGISTER_MATCHER(declCountIs);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(declRefExpr);
REGISTER_MATCHER(declStmt);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(declaratorDecl);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(decltypeType);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(defaultStmt);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(dependentSizedArrayType);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(designatedInitExpr);
REGISTER_MATCHER(designatorCountIs);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(doStmt);
Add support for eachOf/allOf/anyOf variadic matchers in the dynamic layer. Summary: Add support for eachOf/allOf/anyOf variadic matchers in the dynamic layer. These function require some late binding behavior for the type conversions, thus changes in VariadicValue's MatcherList. Second try. This time with a fix for C++11 builds. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1536 llvm-svn: 189500
2013-08-29 02:42:04 +08:00
REGISTER_MATCHER(eachOf);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(elaboratedType);
REGISTER_MATCHER(enumConstantDecl);
REGISTER_MATCHER(enumDecl);
[ASTMatcher] Add a node matcher for EnumType. Reviewers: aaron.ballman Subscribers: cfe-commits, klimek Differential Revision: http://reviews.llvm.org/D21860 llvm-svn: 274217
2016-06-30 15:50:01 +08:00
REGISTER_MATCHER(enumType);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(equalsBoundNode);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(equalsIntegralValue);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(explicitCastExpr);
REGISTER_MATCHER(expr);
Add matcher for ExprWithCleanups. Summary: Add matcher for ExprWithCleanups. Reviewers: klimek CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D3248 llvm-svn: 205420
2014-04-02 21:12:14 +08:00
REGISTER_MATCHER(exprWithCleanups);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(fieldDecl);
Add matcher for float literals. Patch by Chris Gray! Thanks! llvm-svn: 187232
2013-07-27 02:52:58 +08:00
REGISTER_MATCHER(floatLiteral);
Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. Summary: Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. This facilitates dynamic registration. Change the registry code to use the regular overload resolution mechanism for adaptative matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1402 llvm-svn: 188560
2013-08-17 00:19:42 +08:00
REGISTER_MATCHER(forEach);
Add forEachArgumentWithParam AST matcher. The new matcher allows users to provide a matcher for both the argument of a CallExpr/CxxConstructExpr a well as the ParmVarDecl of the argument. Patch by Felix Berger. Differential Revision: http://reviews.llvm.org/D13845 llvm-svn: 258042
2016-01-18 19:20:09 +08:00
REGISTER_MATCHER(forEachArgumentWithParam);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(forEachConstructorInitializer);
Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. Summary: Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. This facilitates dynamic registration. Change the registry code to use the regular overload resolution mechanism for adaptative matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1402 llvm-svn: 188560
2013-08-17 00:19:42 +08:00
REGISTER_MATCHER(forEachDescendant);
[ASTMatchers] Expose forEachOverriden in dynamic AST matchers. llvm-svn: 316344
2017-10-24 00:48:46 +08:00
REGISTER_MATCHER(forEachOverridden);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(forEachSwitchCase);
Add CXXCtorInitializer related matchers to the dynamic matcher registry. Summary: Now that CXXCtorInitializer is already supported in ASTNodeKind, add CXXCtorInitializer matchers to the dynamic matcher registry. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1158 llvm-svn: 186508
2013-07-17 22:28:00 +08:00
REGISTER_MATCHER(forField);
[ASTMatchers] New matcher forFunction Summary: Matcher proposed in the review of checker misc-assign-operator (name pending). Its goal is to find the direct enclosing function declaration of a statement and run the inner matcher on it. Two version is attached in this patch (thus it will not compile), to be decided which approach to take. The second one always chooses one single parent while the first one does a depth-first search upwards (thus a height-first search) and returns the first positive match of the inner matcher (thus it always returns zero or one matches, not more). Further questions: is it enough to implement it in-place, or ASTMatchersInternals or maybe ASTMatchFinder should be involved? Reviewers: sbenza Subscribers: aaron.ballman, klimek, o.gyorgy, xazax.hun, cfe-commits Differential Revision: http://reviews.llvm.org/D19357 llvm-svn: 268490
2016-05-04 19:59:39 +08:00
REGISTER_MATCHER(forFunction);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(forStmt);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(friendDecl);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(functionDecl);
Reapply r259210 with a fix for RegistryTest.cpp. Patch by Richard Thomson. llvm-svn: 259359
2016-02-01 22:11:47 +08:00
REGISTER_MATCHER(functionProtoType);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(functionTemplateDecl);
REGISTER_MATCHER(functionType);
Registering the gnuNullExpr AST matcher as a dynamic matcher so that it is available from clang-query. llvm-svn: 260222
2016-02-09 22:04:49 +08:00
REGISTER_MATCHER(gnuNullExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(gotoStmt);
Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. Summary: Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. This facilitates dynamic registration. Change the registry code to use the regular overload resolution mechanism for adaptative matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1402 llvm-svn: 188560
2013-08-17 00:19:42 +08:00
REGISTER_MATCHER(has);
REGISTER_MATCHER(hasAncestor);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(hasAnyArgument);
[ASTTypeTraits][ASTMatchers][OpenMP] OMPClause handling Summary: `OMPClause` is the base class, it is not descendant from **any** other class, therefore for it to work with e.g. `VariadicDynCastAllOfMatcher<>`, it needs to be handled here. Reviewers: sbenza, bkramer, pcc, klimek, hokein, gribozavr, aaron.ballman, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, alexfh, ABataev, cfe-commits Tags: #openmp, #clang Differential Revision: https://reviews.llvm.org/D57112 llvm-svn: 356675
2019-03-21 23:33:24 +08:00
REGISTER_MATCHER(hasAnyClause);
Add CXXCtorInitializer related matchers to the dynamic matcher registry. Summary: Now that CXXCtorInitializer is already supported in ASTNodeKind, add CXXCtorInitializer matchers to the dynamic matcher registry. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1158 llvm-svn: 186508
2013-07-17 22:28:00 +08:00
REGISTER_MATCHER(hasAnyConstructorInitializer);
[ASTMatchers] Add matchers canReferToDecl() and hasUnderlyingDecl() Summary: Required for D22220 Reviewers: sbenza, klimek, aaron.ballman, alexfh Subscribers: alexfh, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D23004 llvm-svn: 278123
2016-08-09 23:07:52 +08:00
REGISTER_MATCHER(hasAnyDeclaration);
[ASTMatchers] Add matcher hasAnyName. Summary: Add matcher hasAnyName as an optimization over anyOf(hasName(),...) Reviewers: alexfh Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D17163 llvm-svn: 261574
2016-02-23 05:13:02 +08:00
REGISTER_MATCHER(hasAnyName);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasAnyParameter);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(hasAnySelector);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasAnySubstatement);
Add TemplateArgument related matchers to the registry. Summary: Continue adding more matchers to the dynamic registry. This time, we add TemplateArgument matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1166 llvm-svn: 186514
2013-07-17 23:11:30 +08:00
REGISTER_MATCHER(hasAnyTemplateArgument);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasAnyUsingShadowDecl);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(hasArgument);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasArgumentOfType);
[ASTMatchers] Matchers for new[] operators Two new matchers for `CXXNewExpr` are added which may be useful e.g. in `clang-tidy` checkers. One of them is `isArray` which matches `new[]` but not plain `new`. The other one, `hasArraySize` matches `new[]` for a given size. llvm-svn: 318909
2017-11-23 20:43:20 +08:00
REGISTER_MATCHER(hasArraySize);
Add hasAttr matcher for declarations. Delete special-case CUDA attribute matchers. Patch by Jacques Pienaar. llvm-svn: 216379
2014-08-25 19:23:50 +08:00
REGISTER_MATCHER(hasAttr);
Re-committing r253473 after hopefully fixing the bot breakage. There was a copy-pasta issue that my local testing did not catch. llvm-svn: 253481
2015-11-19 01:56:55 +08:00
REGISTER_MATCHER(hasAutomaticStorageDuration);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasBase);
Add AST matchers for handling bit-fields and narrowing based on their width. llvm-svn: 274652
2016-07-07 02:25:16 +08:00
REGISTER_MATCHER(hasBitWidth);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(hasBody);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasCanonicalType);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(hasCaseConstant);
Add an AST matcher for CastExpr kind Summary: This AST matcher will match a given CastExpr kind. It's an narrowing matcher on CastExpr. Reviewers: klimek, alexfh, sbenza, aaron.ballman Subscribers: Prazek, jroelofs, aaron.ballman, klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D19871 llvm-svn: 269460
2016-05-14 03:36:55 +08:00
REGISTER_MATCHER(hasCastKind);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(hasCondition);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasConditionVariableStatement);
Add decayedType and hasDecayedType AST matchers Summary: Add decayedType and hasDecayedType AST matchers Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D13639 llvm-svn: 250114
2015-10-13 05:46:07 +08:00
REGISTER_MATCHER(hasDecayedType);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(hasDeclContext);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(hasDeclaration);
Add support for type traversal matchers. Summary: Fixup the type traversal macros/matchers to specify the supported types. Make the marshallers a little more generic to support any variadic function. Update the doc script. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1023 llvm-svn: 186340
2013-07-16 03:25:06 +08:00
REGISTER_MATCHER(hasDeducedType);
Add an AST matcher for hasDefaultArgument() to match on parameter declarations that have a default value. Patch by Julie Hockett. llvm-svn: 318794
2017-11-22 03:22:34 +08:00
REGISTER_MATCHER(hasDefaultArgument);
Add the hasDefinition() AST matcher to match class declarations that also have a definition. Patch by Julie Hockett. llvm-svn: 319360
2017-11-30 05:21:51 +08:00
REGISTER_MATCHER(hasDefinition);
Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. Summary: Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. This facilitates dynamic registration. Change the registry code to use the regular overload resolution mechanism for adaptative matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1402 llvm-svn: 188560
2013-08-17 00:19:42 +08:00
REGISTER_MATCHER(hasDescendant);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasDestinationType);
Add the hasDynamicExceptionSpec() AST matcher to match function declarations that have a dynamic exception specification. Patch by Don Hinton. llvm-svn: 269662
2016-05-17 00:49:01 +08:00
REGISTER_MATCHER(hasDynamicExceptionSpec);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasEitherOperand);
Add support for type traversal matchers. Summary: Fixup the type traversal macros/matchers to specify the supported types. Make the marshallers a little more generic to support any variadic function. Update the doc script. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1023 llvm-svn: 186340
2013-07-16 03:25:06 +08:00
REGISTER_MATCHER(hasElementType);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(hasElse);
[clang] Adapt ASTMatcher to explicit(bool) specifier Summary: Changes: - add an ast matcher for deductiong guide. - allow isExplicit matcher for deductiong guide. - add hasExplicitSpecifier matcher which give access to the expression of the explicit specifier if present. Reviewers: klimek, rsmith, aaron.ballman Reviewed By: aaron.ballman Subscribers: aaron.ballman, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61552 llvm-svn: 363855
2019-06-20 02:27:56 +08:00
REGISTER_MATCHER(hasExplicitSpecifier);
Add an AST matcher for external formal linkage. Patch by Visoiu Mistrih llvm-svn: 278926
2016-08-17 21:10:42 +08:00
REGISTER_MATCHER(hasExternalFormalLinkage);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasFalseExpression);
Add hasLocalStorage/hasGlobalStorage matchers. Summary: Add hasLocalStorage/hasGlobalStorage matchers for VarDecl nodes. Update the doc. Also add them to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4034 llvm-svn: 210278
2014-06-06 02:22:14 +08:00
REGISTER_MATCHER(hasGlobalStorage);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasImplicitDestinationType);
[ASTMatchers] Add hasInClassInitializer traversal matcher for FieldDecl. Summary: I needed to know whether a FieldDecl had an in-class initializer for D26453. I used a narrowing matcher there, but a traversal matcher might be generally useful. Reviewers: sbenza, bkramer, klimek, aaron.ballman Subscribers: aaron.ballman, Prazek, cfe-commits Differential Revision: https://reviews.llvm.org/D28034 llvm-svn: 290492
2016-12-24 21:35:14 +08:00
REGISTER_MATCHER(hasInClassInitializer);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasIncrement);
REGISTER_MATCHER(hasIndex);
[clang] Add AST matcher for initializer list members Summary: Much like hasArg for various call expressions, this allows LibTooling users to match against a member of an initializer list. This is currently being used as part of the abseil-duration-scale clang-tidy check. Differential Revision: https://reviews.llvm.org/D56090 llvm-svn: 350523
2019-01-07 22:14:36 +08:00
REGISTER_MATCHER(hasInit);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasInitializer);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(hasKeywordSelector);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasLHS);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasLocalQualifiers);
Add hasLocalStorage/hasGlobalStorage matchers. Summary: Add hasLocalStorage/hasGlobalStorage matchers for VarDecl nodes. Update the doc. Also add them to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4034 llvm-svn: 210278
2014-06-06 02:22:14 +08:00
REGISTER_MATCHER(hasLocalStorage);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasLoopInit);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(hasLoopVariable);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasMethod);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasName);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(hasNullSelector);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasObjectExpression);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(hasOperatorName);
REGISTER_MATCHER(hasOverloadedOperatorName);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasParameter);
Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. Summary: Refactor ArgumentAdaptativeMatcher matchers to remove the template from their declaration. This facilitates dynamic registration. Change the registry code to use the regular overload resolution mechanism for adaptative matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1402 llvm-svn: 188560
2013-08-17 00:19:42 +08:00
REGISTER_MATCHER(hasParent);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasQualifier);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(hasRHS);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(hasRangeInit);
[ASTMatchers] Introduce Objective-C matchers `hasReceiver` and `isInstanceMessage` for ObjCMessageExpr Differential Revision: https://reviews.llvm.org/D49333 llvm-svn: 337209
2018-07-17 04:22:12 +08:00
REGISTER_MATCHER(hasReceiver);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(hasReceiverType);
[ASTMatcher] Add hasReplacementType matcher for SubstTemplateTypeParmType Summary: Needed for https://reviews.llvm.org/D27166 Reviewers: sbenza, bkramer, klimek Subscribers: aemerson, cfe-commits Differential Revision: https://reviews.llvm.org/D27447 llvm-svn: 289042
2016-12-08 19:46:22 +08:00
REGISTER_MATCHER(hasReplacementType);
[ASTMatchers] New matcher hasReturnValue added Summary: A checker (will be uploaded after this patch) needs to check implicit casts. Existing generic matcher "has" ignores implicit casts and parenthesized expressions and no specific matcher for matching return value expression preexisted. The patch adds such a matcher (hasReturnValue). Reviewers: klimek, sbenza Subscribers: xazax.hun, klimek, cfe-commits Patch by Ádám Balogh! Differential Revision: http://reviews.llvm.org/D17986 llvm-svn: 264037
2016-03-22 19:03:03 +08:00
REGISTER_MATCHER(hasReturnValue);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(hasSelector);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasSingleDecl);
REGISTER_MATCHER(hasSize);
REGISTER_MATCHER(hasSizeExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasSourceExpression);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(hasSpecializedTemplate);
Re-committing r253473 after hopefully fixing the bot breakage. There was a copy-pasta issue that my local testing did not catch. llvm-svn: 253481
2015-11-19 01:56:55 +08:00
REGISTER_MATCHER(hasStaticStorageDuration);
[ASTMatchers][OpenMP] OpenMP Structured-block-related matchers Summary: Exposes to the for ASTMatchers the interface/modelling of OpenMP structured-block. Reviewers: gribozavr, aaron.ballman, JonasToth, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, cfe-commits Tags: #clang, #openmp Differential Revision: https://reviews.llvm.org/D59463 llvm-svn: 356676
2019-03-21 23:33:35 +08:00
REGISTER_MATCHER(hasStructuredBlock);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(hasSyntacticForm);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(hasTargetDecl);
Add TemplateArgument related matchers to the registry. Summary: Continue adding more matchers to the dynamic registry. This time, we add TemplateArgument matchers. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1166 llvm-svn: 186514
2013-07-17 23:11:30 +08:00
REGISTER_MATCHER(hasTemplateArgument);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(hasThen);
Re-committing r253473 after hopefully fixing the bot breakage. There was a copy-pasta issue that my local testing did not catch. llvm-svn: 253481
2015-11-19 01:56:55 +08:00
REGISTER_MATCHER(hasThreadStorageDuration);
Add hasTrailingReturn AST matcher Adds AST matcher for a FunctionDecl that has a trailing return type. Differential Revision: https://reviews.llvm.org/D42273 llvm-svn: 323158
2018-01-23 06:45:23 +08:00
REGISTER_MATCHER(hasTrailingReturn);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasTrueExpression);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(hasTypeLoc);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(hasUnaryOperand);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(hasUnarySelector);
[ASTMatchers] Add matchers canReferToDecl() and hasUnderlyingDecl() Summary: Required for D22220 Reviewers: sbenza, klimek, aaron.ballman, alexfh Subscribers: alexfh, klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D23004 llvm-svn: 278123
2016-08-09 23:07:52 +08:00
REGISTER_MATCHER(hasUnderlyingDecl);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(hasUnderlyingType);
Adds hasUnqualifiedDesugaredType to allow matching through type sugar. Differential Revision: https://reviews.llvm.org/D27207 llvm-svn: 288366
2016-12-01 23:45:06 +08:00
REGISTER_MATCHER(hasUnqualifiedDesugaredType);
Add support for type traversal matchers. Summary: Fixup the type traversal macros/matchers to specify the supported types. Make the marshallers a little more generic to support any variadic function. Update the doc script. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1023 llvm-svn: 186340
2013-07-16 03:25:06 +08:00
REGISTER_MATCHER(hasValueType);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(ifStmt);
Added AST matcher for ignoring elidable constructors Summary: Added AST matcher for ignoring elidable move constructors Reviewers: hokein, gribozavr Reviewed By: hokein, gribozavr Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63149 Patch by Johan Vikström. llvm-svn: 363262
2019-06-13 21:48:24 +08:00
REGISTER_MATCHER(ignoringElidableConstructorCall);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(ignoringImpCasts);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(ignoringImplicit);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(ignoringParenCasts);
REGISTER_MATCHER(ignoringParenImpCasts);
[ASTMatcher] Add missing imaginaryLiteral llvm-svn: 344026
2018-10-09 16:44:28 +08:00
REGISTER_MATCHER(imaginaryLiteral);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(implicitCastExpr);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(implicitValueInitExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(incompleteArrayType);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(indirectFieldDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(initListExpr);
Fixed HasDeclarationMatcher to properly convert all types into decls where possible. Added objcObjectPointerType(), objcInterfaceDecl(), templateTypeParmType(), injectedClassNameType(), and unresolvedUsingTypenameDecl(). Updated documentation for pointerType() to call out that it does not match ObjCObjectPointerType types. Changed pointsTo() to handle ObjCObjectPointerType as well as PointerType. While this may seem like a lot of unrelated changes, they all relate back to fixing HasDeclarationMatcher. This now allows us to write a matcher like: varDecl(hasType(namedDecl(hasName("Foo")))) that matches code using typedefs, objc interfaces, template type parameters, injected class names, or unresolved using typenames. llvm-svn: 247404
2015-09-11 19:51:24 +08:00
REGISTER_MATCHER(injectedClassNameType);
Add support for type traversal matchers. Summary: Fixup the type traversal macros/matchers to specify the supported types. Make the marshallers a little more generic to support any variadic function. Update the doc script. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1023 llvm-svn: 186340
2013-07-16 03:25:06 +08:00
REGISTER_MATCHER(innerType);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(integerLiteral);
[ASTTypeTraits][ASTMatchers][OpenMP] OMPClause handling Summary: `OMPClause` is the base class, it is not descendant from **any** other class, therefore for it to work with e.g. `VariadicDynCastAllOfMatcher<>`, it needs to be handled here. Reviewers: sbenza, bkramer, pcc, klimek, hokein, gribozavr, aaron.ballman, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, alexfh, ABataev, cfe-commits Tags: #openmp, #clang Differential Revision: https://reviews.llvm.org/D57112 llvm-svn: 356675
2019-03-21 23:33:24 +08:00
REGISTER_MATCHER(isAllowedToContainClauseKind);
Add AST narrowing matchers for inline and anonymous namespaces. Since the inline keyword can also be specified on a FunctionDecl, this is a polymorphic matcher. llvm-svn: 245337
2015-08-19 03:55:20 +08:00
REGISTER_MATCHER(isAnonymous);
Add isAnyPointer() matchers. Register missing matchers. Summary: The isAnyPointer() matcher is useful for http://reviews.llvm.org/D15623. Reviewers: alexfh, klimek Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D15819 llvm-svn: 260872
2016-02-15 12:00:39 +08:00
REGISTER_MATCHER(isAnyCharacter);
REGISTER_MATCHER(isAnyPointer);
[ASTMatchers] Matchers for new[] operators Two new matchers for `CXXNewExpr` are added which may be useful e.g. in `clang-tidy` checkers. One of them is `isArray` which matches `new[]` but not plain `new`. The other one, `hasArraySize` matches `new[]` for a given size. llvm-svn: 318909
2017-11-23 20:43:20 +08:00
REGISTER_MATCHER(isArray);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(isArrow);
[ASTMatchers] Add isAssignmentOperator matcher Adding a matcher for BinaryOperator and cxxOperatorCallExpr to be able to decide whether it is any kind of assignment operator or not. This would be useful since allows us to easily detect assignments via matchers for static analysis (Tidy, SA) purposes. Differential Revision: https://reviews.llvm.org/D44893 llvm-svn: 328618
2018-03-27 20:11:46 +08:00
REGISTER_MATCHER(isAssignmentOperator);
Add AST matchers for narrowing constructors that are default, copy, or move constructors, as well as functionality to determine whether a ctor initializer is a base initializer. llvm-svn: 244036
2015-08-05 20:11:30 +08:00
REGISTER_MATCHER(isBaseInitializer);
Add AST matchers for handling bit-fields and narrowing based on their width. llvm-svn: 274652
2016-07-07 02:25:16 +08:00
REGISTER_MATCHER(isBitField);
Implement an AST matcher for C++ exception catch handlers that can catch any exception type (...). llvm-svn: 241256
2015-07-02 20:53:22 +08:00
REGISTER_MATCHER(isCatchAll);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(isClass);
[ASTMatchers] Introduce Objective-C matchers `isClassMessage`, `isClassMethod`, and `isInstanceMethod` Summary: isClassMessage is an equivalent to isInstanceMessage for ObjCMessageExpr, but matches message expressions to classes. isClassMethod and isInstanceMethod check whether a method declaration (or definition) is for a class method or instance method (respectively). Contributed by @mywman! Reviewers: benhamilton, klimek, mwyman Reviewed By: benhamilton, mwyman Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60920 llvm-svn: 358904
2019-04-23 01:54:11 +08:00
REGISTER_MATCHER(isClassMessage);
REGISTER_MATCHER(isClassMethod);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(isConst);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(isConstQualified);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(isConstexpr);
Register the isCopyAssignmentOperator AST matcher so that it can be used dynamically. Path by Jonathan Coe. llvm-svn: 258341
2016-01-21 04:47:58 +08:00
REGISTER_MATCHER(isCopyAssignmentOperator);
Add AST matchers for narrowing constructors that are default, copy, or move constructors, as well as functionality to determine whether a ctor initializer is a base initializer. llvm-svn: 244036
2015-08-05 20:11:30 +08:00
REGISTER_MATCHER(isCopyConstructor);
REGISTER_MATCHER(isDefaultConstructor);
Add an AST matcher for checking whether a function is defaulted. Patch by Jonathan Coe. llvm-svn: 258072
2016-01-19 04:37:44 +08:00
REGISTER_MATCHER(isDefaulted);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(isDefinition);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(isDelegatingConstructor);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(isDeleted);
Add the ability to AST match a variable declaration that is an exception variable. llvm-svn: 242303
2015-07-16 01:11:21 +08:00
REGISTER_MATCHER(isExceptionVariable);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(isExpansionInFileMatching);
REGISTER_MATCHER(isExpansionInMainFile);
REGISTER_MATCHER(isExpansionInSystemHeader);
Add a polymorphic AST matcher for testing whether a constructor or a conversion declaration is marked as explicit or not. llvm-svn: 244666
2015-08-12 05:09:52 +08:00
REGISTER_MATCHER(isExplicit);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(isExplicitTemplateSpecialization);
Add TemplateSpecializationType polymorphism for hasTemplateArgument and hasAnyTemplateArgument, and (out of necessity) an isExpr matcher. Also updates the TemplateArgument doxygen to reflect reality for non-canonical template arguments. Differential Revision: http://llvm-reviews.chandlerc.com/D2810 llvm-svn: 201804
2014-02-21 03:18:03 +08:00
REGISTER_MATCHER(isExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(isExternC);
Add an AST matcher, isFinal(), for testing whether a method or class declaration are marked final. llvm-svn: 243107
2015-07-24 20:35:41 +08:00
REGISTER_MATCHER(isFinal);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(isImplicit);
Added an AST matcher for declarations that are in the `std` namespace Reviewers: alexfh Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61480 llvm-svn: 359876
2019-05-03 20:50:00 +08:00
REGISTER_MATCHER(isInStdNamespace);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(isInTemplateInstantiation);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(isInline);
[ASTMatchers] Introduce Objective-C matchers `hasReceiver` and `isInstanceMessage` for ObjCMessageExpr Differential Revision: https://reviews.llvm.org/D49333 llvm-svn: 337209
2018-07-17 04:22:12 +08:00
REGISTER_MATCHER(isInstanceMessage);
[ASTMatchers] Introduce Objective-C matchers `isClassMessage`, `isClassMethod`, and `isInstanceMethod` Summary: isClassMessage is an equivalent to isInstanceMessage for ObjCMessageExpr, but matches message expressions to classes. isClassMethod and isInstanceMethod check whether a method declaration (or definition) is for a class method or instance method (respectively). Contributed by @mywman! Reviewers: benhamilton, klimek, mwyman Reviewed By: benhamilton, mwyman Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60920 llvm-svn: 358904
2019-04-23 01:54:11 +08:00
REGISTER_MATCHER(isInstanceMethod);
ASTMatchers: Add a matcher to detect whether a decl or stmt is inside a template instantiation. This is hoisted from clang-tidy where it's used everywhere. The implementation is not particularly efficient right now, but there is no easy fix for that. Differential Revision: http://reviews.llvm.org/D5085 llvm-svn: 217029
2014-09-03 20:08:14 +08:00
REGISTER_MATCHER(isInstantiated);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(isInstantiationDependent);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(isInteger);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(isIntegral);
[ASTMatchers] Add isLambda() matcher. llvm-svn: 274015
2016-06-28 22:08:56 +08:00
REGISTER_MATCHER(isLambda);
Add isListInitialization matcher. Differential Revision: http://llvm-reviews.chandlerc.com/D2708 llvm-svn: 200949
2014-02-07 05:52:24 +08:00
REGISTER_MATCHER(isListInitialization);
[ASTMatchers] Add an isMain() matcher Differential Revision: https://reviews.llvm.org/D49615 llvm-svn: 337761
2018-07-24 06:29:35 +08:00
REGISTER_MATCHER(isMain);
Add an AST matcher to match member intializers of a CXXCtorInitializer. llvm-svn: 244662
2015-08-12 04:42:00 +08:00
REGISTER_MATCHER(isMemberInitializer);
Add am AST matcher for isMoveAssignmentOperator. Patch by Jonathan Coe. llvm-svn: 258573
2016-01-23 06:37:09 +08:00
REGISTER_MATCHER(isMoveAssignmentOperator);
Add AST matchers for narrowing constructors that are default, copy, or move constructors, as well as functionality to determine whether a ctor initializer is a base initializer. llvm-svn: 244036
2015-08-05 20:11:30 +08:00
REGISTER_MATCHER(isMoveConstructor);
[ASTMatchers] Add isNoReturn() match narrower for FunctionDeclarations Reviewers: aaron.ballman Reviewed By: aaron.ballman Subscribers: dblaikie, klimek, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D41455 llvm-svn: 322746
2018-01-18 03:40:55 +08:00
REGISTER_MATCHER(isNoReturn);
Add a narrowing AST matcher that matches on a FunctionDecl with a non-throwing exception specification. llvm-svn: 254516
2015-12-02 23:23:59 +08:00
REGISTER_MATCHER(isNoThrow);
[ASTTypeTraits][ASTMatchers][OpenMP] OMPClause handling Summary: `OMPClause` is the base class, it is not descendant from **any** other class, therefore for it to work with e.g. `VariadicDynCastAllOfMatcher<>`, it needs to be handled here. Reviewers: sbenza, bkramer, pcc, klimek, hokein, gribozavr, aaron.ballman, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, alexfh, ABataev, cfe-commits Tags: #openmp, #clang Differential Revision: https://reviews.llvm.org/D57112 llvm-svn: 356675
2019-03-21 23:33:24 +08:00
REGISTER_MATCHER(isNoneKind);
[ASTMatchers][OpenMP] OpenMP Structured-block-related matchers Summary: Exposes to the for ASTMatchers the interface/modelling of OpenMP structured-block. Reviewers: gribozavr, aaron.ballman, JonasToth, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, cfe-commits Tags: #clang, #openmp Differential Revision: https://reviews.llvm.org/D59463 llvm-svn: 356676
2019-03-21 23:33:35 +08:00
REGISTER_MATCHER(isOMPStructuredBlock);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(isOverride);
REGISTER_MATCHER(isPrivate);
REGISTER_MATCHER(isProtected);
REGISTER_MATCHER(isPublic);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(isPure);
[ASTMatcher] Add isScoped matcher for enumDecl. Summary: Reviewers: bkramer, aaron.ballman Subscribers: aaron.ballman, cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D42185 llvm-svn: 322826
2018-01-18 17:47:57 +08:00
REGISTER_MATCHER(isScoped);
[ASTTypeTraits][ASTMatchers][OpenMP] OMPClause handling Summary: `OMPClause` is the base class, it is not descendant from **any** other class, therefore for it to work with e.g. `VariadicDynCastAllOfMatcher<>`, it needs to be handled here. Reviewers: sbenza, bkramer, pcc, klimek, hokein, gribozavr, aaron.ballman, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, alexfh, ABataev, cfe-commits Tags: #openmp, #clang Differential Revision: https://reviews.llvm.org/D57112 llvm-svn: 356675
2019-03-21 23:33:24 +08:00
REGISTER_MATCHER(isSharedKind);
[ASTMatchers] isSignedInteger() and isUnsignedInteger() Complementary to isInteger(), these match signed and unsigned integers respectively. Review: http://reviews.llvm.org/D21989 llvm-svn: 275157
2016-07-12 14:36:00 +08:00
REGISTER_MATCHER(isSignedInteger);
[ASTMatchers][OpenMP] OpenMP Structured-block-related matchers Summary: Exposes to the for ASTMatchers the interface/modelling of OpenMP structured-block. Reviewers: gribozavr, aaron.ballman, JonasToth, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, cfe-commits Tags: #clang, #openmp Differential Revision: https://reviews.llvm.org/D59463 llvm-svn: 356676
2019-03-21 23:33:35 +08:00
REGISTER_MATCHER(isStandaloneDirective);
Add the isStaticLocal() AST matcher for matching on local static variables. Patch by Joe Ranieri. llvm-svn: 345502
2018-10-29 21:47:56 +08:00
REGISTER_MATCHER(isStaticLocal);
Add isStaticStorageClass to the dynamic matcher registry so that it can be used from clang-query. Patch by Dave Lee. llvm-svn: 300400
2017-04-15 20:53:20 +08:00
REGISTER_MATCHER(isStaticStorageClass);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(isStruct);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
REGISTER_MATCHER(isTemplateInstantiation);
[ASTMatchers] add three matchers for dependent expressions Summary: The new matchers can be used to check if an expression is type-, value- or instantiation-dependent in a templated context. These matchers are used in a clang-tidy check and generally useful as the problem of unresolved templates occurs more often in clang-tidy and they provide an easy way to check for this issue. Reviewers: aaron.ballman, alexfh, klimek Reviewed By: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51880 llvm-svn: 341958
2018-09-12 00:09:19 +08:00
REGISTER_MATCHER(isTypeDependent);
Rename AST node matchers to match the AST node names directly. Part of this rename also splits recordDecl() (which used to match CXXRecordDecl) into recordDecl() (that matches RecordDecl) and cxxRecordDecl (that matches CXXRecordDecl). Also adds isStruct(), isUnion(), and isClass() narrowing matchers for RecordDecl objects. llvm-svn: 247885
2015-09-17 21:30:52 +08:00
REGISTER_MATCHER(isUnion);
[ASTMatchers] isSignedInteger() and isUnsignedInteger() Complementary to isInteger(), these match signed and unsigned integers respectively. Review: http://reviews.llvm.org/D21989 llvm-svn: 275157
2016-07-12 14:36:00 +08:00
REGISTER_MATCHER(isUnsignedInteger);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(isUserProvided);
[ASTMatchers] add three matchers for dependent expressions Summary: The new matchers can be used to check if an expression is type-, value- or instantiation-dependent in a templated context. These matchers are used in a clang-tidy check and generally useful as the problem of unresolved templates occurs more often in clang-tidy and they provide an easy way to check for this issue. Reviewers: aaron.ballman, alexfh, klimek Reviewed By: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51880 llvm-svn: 341958
2018-09-12 00:09:19 +08:00
REGISTER_MATCHER(isValueDependent);
Adding a narrowing AST matcher for FunctionDecl::isVariadic(), plus tests and documentation. llvm-svn: 249321
2015-10-05 22:41:27 +08:00
REGISTER_MATCHER(isVariadic);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(isVirtual);
Add an isVirtualAsWritten AST matcher. http://reviews.llvm.org/D16394 llvm-svn: 258415
2016-01-22 01:56:24 +08:00
REGISTER_MATCHER(isVirtualAsWritten);
Add an AST matcher for narrowing when a type is volatile-qualified. llvm-svn: 253882
2015-11-24 01:09:24 +08:00
REGISTER_MATCHER(isVolatileQualified);
Add CXXCtorInitializer related matchers to the dynamic matcher registry. Summary: Now that CXXCtorInitializer is already supported in ASTNodeKind, add CXXCtorInitializer matchers to the dynamic matcher registry. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1158 llvm-svn: 186508
2013-07-17 22:28:00 +08:00
REGISTER_MATCHER(isWritten);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(lValueReferenceType);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(labelDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(labelStmt);
REGISTER_MATCHER(lambdaExpr);
Register linkageSpecDecl matcher Summary: This allows `linkageSpecDecl` to be used from `clang-query`. See also D31869 which similary adds `isStaticStorageClass`. Reviewers: aaron.ballman Reviewed By: aaron.ballman Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D37346 llvm-svn: 312283
2017-09-01 05:18:27 +08:00
REGISTER_MATCHER(linkageSpecDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(matchesName);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(matchesSelector);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(materializeTemporaryExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(member);
REGISTER_MATCHER(memberExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(memberPointerType);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(namedDecl);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(namesType);
Adding an AST matcher for namespaceAliasDecl. llvm-svn: 246322
2015-08-29 03:39:21 +08:00
REGISTER_MATCHER(namespaceAliasDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(namespaceDecl);
REGISTER_MATCHER(nestedNameSpecifier);
REGISTER_MATCHER(nestedNameSpecifierLoc);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(nonTypeTemplateParmDecl);
Add a nullPointerConstant() AST matcher to handle variations of null pointer constants in one matcher. llvm-svn: 261008
2016-02-17 05:02:23 +08:00
REGISTER_MATCHER(nullPointerConstant);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(nullStmt);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(numSelectorArgs);
Add ObjC exception statement AST matchers Summary: Add AST matchers for Objective-C @throw, @try, @catch and @finally. Reviewers: aaron.ballman, malcolm.parsons, alexshap, compnerd Reviewed By: aaron.ballman Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D39940 llvm-svn: 317992
2017-11-12 06:46:15 +08:00
REGISTER_MATCHER(objcCatchStmt);
Add AST matchers for ObjCProtocolDecl, ObjCCategoryDecl, ObjCMethodDecl, ObjCIvarDecl, and ObjCPropertyDecl. Patch by Dave Lee. llvm-svn: 297882
2017-03-16 04:14:25 +08:00
REGISTER_MATCHER(objcCategoryDecl);
Add objcCategoryImplDecl matcher Summary: Add `objcCategoryImplDecl` which matches ObjC category definitions (`@implementation`). This matcher complements `objcCategoryDecl` (`@interface`) which was added in D30854. Reviewers: aaron.ballman, malcolm.parsons, alexshap Reviewed By: aaron.ballman Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D39293 llvm-svn: 316670
2017-10-26 23:53:37 +08:00
REGISTER_MATCHER(objcCategoryImplDecl);
Add ObjC exception statement AST matchers Summary: Add AST matchers for Objective-C @throw, @try, @catch and @finally. Reviewers: aaron.ballman, malcolm.parsons, alexshap, compnerd Reviewed By: aaron.ballman Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D39940 llvm-svn: 317992
2017-11-12 06:46:15 +08:00
REGISTER_MATCHER(objcFinallyStmt);
Add objcImplementationDecl matcher Summary: Add the `objcImplementationDecl` matcher. See related: D30854 Tested with: ``` ./tools/clang/unittests/ASTMatchers/ASTMatchersTests ``` Reviewers: aaron.ballman, compnerd, alexshap Reviewed By: aaron.ballman Subscribers: klimek, cfe-commits Differential Revision: https://reviews.llvm.org/D37643 llvm-svn: 312889
2017-09-11 05:00:15 +08:00
REGISTER_MATCHER(objcImplementationDecl);
Fixed HasDeclarationMatcher to properly convert all types into decls where possible. Added objcObjectPointerType(), objcInterfaceDecl(), templateTypeParmType(), injectedClassNameType(), and unresolvedUsingTypenameDecl(). Updated documentation for pointerType() to call out that it does not match ObjCObjectPointerType types. Changed pointsTo() to handle ObjCObjectPointerType as well as PointerType. While this may seem like a lot of unrelated changes, they all relate back to fixing HasDeclarationMatcher. This now allows us to write a matcher like: varDecl(hasType(namedDecl(hasName("Foo")))) that matches code using typedefs, objc interfaces, template type parameters, injected class names, or unresolved using typenames. llvm-svn: 247404
2015-09-11 19:51:24 +08:00
REGISTER_MATCHER(objcInterfaceDecl);
Add AST matchers for ObjCProtocolDecl, ObjCCategoryDecl, ObjCMethodDecl, ObjCIvarDecl, and ObjCPropertyDecl. Patch by Dave Lee. llvm-svn: 297882
2017-03-16 04:14:25 +08:00
REGISTER_MATCHER(objcIvarDecl);
[ASTMatchers] Introduce a matcher for `ObjCIvarExpr`, support getting it's declaration. ObjCIvarExpr is *not* a subclass of MemberExpr, and a separate matcher is required to support it. Adding a hasDeclaration support as well, as it's not very useful without it. Differential Revision: https://reviews.llvm.org/D49701 llvm-svn: 338137
2018-07-28 01:26:11 +08:00
REGISTER_MATCHER(objcIvarRefExpr);
Add support for a few Objective-C matchers. Add some matchers for Objective-C selectors and messages to ASTMatchers.h. Minor mods to ASTMatchersTest.h to allow test files with ".m" extension in addition to ".cpp". New tests added to ASTMatchersTest.c. Patch by Dean Sutherland. llvm-svn: 232051
2015-03-12 23:48:15 +08:00
REGISTER_MATCHER(objcMessageExpr);
Add AST matchers for ObjCProtocolDecl, ObjCCategoryDecl, ObjCMethodDecl, ObjCIvarDecl, and ObjCPropertyDecl. Patch by Dave Lee. llvm-svn: 297882
2017-03-16 04:14:25 +08:00
REGISTER_MATCHER(objcMethodDecl);
Fixed HasDeclarationMatcher to properly convert all types into decls where possible. Added objcObjectPointerType(), objcInterfaceDecl(), templateTypeParmType(), injectedClassNameType(), and unresolvedUsingTypenameDecl(). Updated documentation for pointerType() to call out that it does not match ObjCObjectPointerType types. Changed pointsTo() to handle ObjCObjectPointerType as well as PointerType. While this may seem like a lot of unrelated changes, they all relate back to fixing HasDeclarationMatcher. This now allows us to write a matcher like: varDecl(hasType(namedDecl(hasName("Foo")))) that matches code using typedefs, objc interfaces, template type parameters, injected class names, or unresolved using typenames. llvm-svn: 247404
2015-09-11 19:51:24 +08:00
REGISTER_MATCHER(objcObjectPointerType);
Add AST matchers for ObjCProtocolDecl, ObjCCategoryDecl, ObjCMethodDecl, ObjCIvarDecl, and ObjCPropertyDecl. Patch by Dave Lee. llvm-svn: 297882
2017-03-16 04:14:25 +08:00
REGISTER_MATCHER(objcPropertyDecl);
REGISTER_MATCHER(objcProtocolDecl);
Add ObjC exception statement AST matchers Summary: Add AST matchers for Objective-C @throw, @try, @catch and @finally. Reviewers: aaron.ballman, malcolm.parsons, alexshap, compnerd Reviewed By: aaron.ballman Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D39940 llvm-svn: 317992
2017-11-12 06:46:15 +08:00
REGISTER_MATCHER(objcThrowStmt);
REGISTER_MATCHER(objcTryStmt);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(ofClass);
[ASTTypeTraits][ASTMatchers][OpenMP] OMPClause handling Summary: `OMPClause` is the base class, it is not descendant from **any** other class, therefore for it to work with e.g. `VariadicDynCastAllOfMatcher<>`, it needs to be handled here. Reviewers: sbenza, bkramer, pcc, klimek, hokein, gribozavr, aaron.ballman, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, alexfh, ABataev, cfe-commits Tags: #openmp, #clang Differential Revision: https://reviews.llvm.org/D57112 llvm-svn: 356675
2019-03-21 23:33:24 +08:00
REGISTER_MATCHER(ompDefaultClause);
[ASTMatchers][OpenMP] Add base ompExecutableDirective() matcher. Summary: A simple matcher for `OMPExecutableDirective` Stmt type. Split off from D57113. Reviewers: gribozavr, aaron.ballman, JonasToth, george.karpenkov Reviewed By: gribozavr, aaron.ballman Subscribers: guansong, jdoerfert, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D59453 llvm-svn: 356674
2019-03-21 23:33:10 +08:00
REGISTER_MATCHER(ompExecutableDirective);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(on);
REGISTER_MATCHER(onImplicitObjectArgument);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(opaqueValueExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(parameterCountIs);
Add AST matcher for paren expressions. Patch by Adrian Zgorzałek. llvm-svn: 258321
2016-01-21 00:17:39 +08:00
REGISTER_MATCHER(parenExpr);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(parenListExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(parenType);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(parmVarDecl);
Add support for type traversal matchers. Summary: Fixup the type traversal macros/matchers to specify the supported types. Make the marshallers a little more generic to support any variadic function. Update the doc script. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1023 llvm-svn: 186340
2013-07-16 03:25:06 +08:00
REGISTER_MATCHER(pointee);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(pointerType);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(predefinedExpr);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(qualType);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(rValueReferenceType);
Add an AST matcher for real floating-point types. e.g., float, double, long double, but not complex. llvm-svn: 261221
2016-02-19 00:36:01 +08:00
REGISTER_MATCHER(realFloatingPointType);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(recordDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(recordType);
REGISTER_MATCHER(referenceType);
REGISTER_MATCHER(refersToDeclaration);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(refersToIntegralType);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(refersToTemplate);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(refersToType);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(requiresZeroInitialization);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(returnStmt);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(returns);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(sizeOfExpr);
REGISTER_MATCHER(specifiesNamespace);
REGISTER_MATCHER(specifiesType);
REGISTER_MATCHER(specifiesTypeLoc);
REGISTER_MATCHER(statementCountIs);
Move a test from static-assert.cpp to DeclPrinterTest It's better not to rely on the diagnostics engine to pretty print the argument to decltype. Instead, exercise the functionality in DeclPrinterTest. llvm-svn: 239197
2015-06-06 06:40:53 +08:00
REGISTER_MATCHER(staticAssertDecl);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(stmt);
Adding new AST matchers for: addrLabelExpr, atomicExpr, binaryConditionalOperator, designatedInitExpr, designatorCountIs, hasSyntacticForm, implicitValueInitExpr, labelDecl, opaqueValueExpr, parenListExpr, predefinedExpr, requiresZeroInitialization, and stmtExpr. Patch by Aleksei Sidorin. llvm-svn: 263027
2016-03-10 01:11:51 +08:00
REGISTER_MATCHER(stmtExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(stringLiteral);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(substNonTypeTemplateParmExpr);
[ASTMatchers] Add type matcher for SubstTemplateTypeParmType. llvm-svn: 246037
2015-08-27 00:15:59 +08:00
REGISTER_MATCHER(substTemplateTypeParmType);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(switchCase);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(switchStmt);
Add matchers missing from dynamic AST registry llvm-svn: 343717
2018-10-04 04:52:51 +08:00
REGISTER_MATCHER(tagType);
Implement various matchers around template argument handling. llvm-svn: 219408
2014-10-09 21:06:22 +08:00
REGISTER_MATCHER(templateArgument);
REGISTER_MATCHER(templateArgumentCountIs);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(templateName);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(templateSpecializationType);
[ASTMatchers] Add templateTypeParmDecl() to Registry.cpp Summary: This appears to have been forgotten when templateTypeParmDecl() was initially added. Reviewers: alexfh, aaron.ballman Subscribers: aaron.ballman, klimek, aemerson, rengolin, samparker, cfe-commits Differential Revision: https://reviews.llvm.org/D23448 llvm-svn: 278507
2016-08-12 21:51:00 +08:00
REGISTER_MATCHER(templateTypeParmDecl);
Fixed HasDeclarationMatcher to properly convert all types into decls where possible. Added objcObjectPointerType(), objcInterfaceDecl(), templateTypeParmType(), injectedClassNameType(), and unresolvedUsingTypenameDecl(). Updated documentation for pointerType() to call out that it does not match ObjCObjectPointerType types. Changed pointsTo() to handle ObjCObjectPointerType as well as PointerType. While this may seem like a lot of unrelated changes, they all relate back to fixing HasDeclarationMatcher. This now allows us to write a matcher like: varDecl(hasType(namedDecl(hasName("Foo")))) that matches code using typedefs, objc interfaces, template type parameters, injected class names, or unresolved using typenames. llvm-svn: 247404
2015-09-11 19:51:24 +08:00
REGISTER_MATCHER(templateTypeParmType);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(throughUsingDecl);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(to);
Add translationUnitDecl matcher. Summary: Add translationUnitDecl matcher. Reviewers: alexfh Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D7512 llvm-svn: 228694
2015-02-10 22:46:45 +08:00
REGISTER_MATCHER(translationUnitDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(type);
Sort list of matchers llvm-svn: 343716
2018-10-04 04:52:45 +08:00
REGISTER_MATCHER(typeAliasDecl);
REGISTER_MATCHER(typeAliasTemplateDecl);
[NFC][ASTMatchers] Alphabetically sort REGISTER_MATCHER() macros in RegistryMaps::RegistryMaps() As noted in https://reviews.llvm.org/D59453#inline-526253 llvm-svn: 356578
2019-03-21 01:15:47 +08:00
REGISTER_MATCHER(typeLoc);
Re-apply r222646 (was reverted in r222667). Adding 4 ASTMatchers: typedefDecl, isInMainFile, isInSystemFile, isInFileMatchingName Change to original: ifndef out tests in Windows due to /-separated paths. Summary: Often one is only interested in matches within the main-file or matches that are not within a system-header, for which this patch adds isInMainFile and isInSystemFile. They take no arguments and narrow down the matches. The isInFileMatchingName is mainly thought for interactive clang-query-sessions, to make a matcher more specific without restarting the session with the files you are interested in for that moment. It takes a string that will be used as regular-expression to match the filename of where the matched node is expanded. Patch by Hendrik von Prince. llvm-svn: 222765
2014-11-26 01:01:06 +08:00
REGISTER_MATCHER(typedefDecl);
Add typedefNameDecl() and typeAliasDecl() to the AST matchers; improves hasType() to match on TypedefNameDecl nodes. Patch by Clement Courbet. llvm-svn: 266331
2016-04-15 00:05:45 +08:00
REGISTER_MATCHER(typedefNameDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(typedefType);
REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(unaryOperator);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(unaryTransformType);
Add support for the 'unless' matcher in the dynamic layer. Summary: Add support for the 'unless' matcher in the dynamic layer. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2247 llvm-svn: 195466
2013-11-22 22:41:48 +08:00
REGISTER_MATCHER(unless);
[ASTMatcher] Add a node matcher for UnresolvedLookupExpr. Reviewers: alexfh, aaron.ballman Subscribers: aaron.ballman, klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D20360 llvm-svn: 269916
2016-05-18 20:53:59 +08:00
REGISTER_MATCHER(unresolvedLookupExpr);
[ASTMatchers] Add matchers unresolvedMemberExpr, cxxDependentScopeMemberExpr Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50606 llvm-svn: 339522
2018-08-13 01:34:36 +08:00
REGISTER_MATCHER(unresolvedMemberExpr);
Fixed HasDeclarationMatcher to properly convert all types into decls where possible. Added objcObjectPointerType(), objcInterfaceDecl(), templateTypeParmType(), injectedClassNameType(), and unresolvedUsingTypenameDecl(). Updated documentation for pointerType() to call out that it does not match ObjCObjectPointerType types. Changed pointsTo() to handle ObjCObjectPointerType as well as PointerType. While this may seem like a lot of unrelated changes, they all relate back to fixing HasDeclarationMatcher. This now allows us to write a matcher like: varDecl(hasType(namedDecl(hasName("Foo")))) that matches code using typedefs, objc interfaces, template type parameters, injected class names, or unresolved using typenames. llvm-svn: 247404
2015-09-11 19:51:24 +08:00
REGISTER_MATCHER(unresolvedUsingTypenameDecl);
Another pass at adding missing matchers into the registry. Summary: Another pass at adding missing matchers into the registry. Reviewers: klimek CC: cfe-commits, revane, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D2253 llvm-svn: 195647
2013-11-25 23:03:44 +08:00
REGISTER_MATCHER(unresolvedUsingValueDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(userDefinedLiteral);
[AST] Store "UsesADL" information in CallExpr. Summary: Currently the Clang AST doesn't store information about how the callee of a CallExpr was found. Specifically if it was found using ADL. However, this information is invaluable to tooling. Consider a tool which renames usages of a function. If the originally CallExpr was formed using ADL, then the tooling may need to additionally qualify the replacement. Without information about how the callee was found, the tooling is left scratching it's head. Additionally, we want to be able to match ADL calls as quickly as possible, which means avoiding computing the answer on the fly. This patch changes `CallExpr` to store whether it's callee was found using ADL. It does not change the size of any AST nodes. Reviewers: fowles, rsmith, klimek, shafik Reviewed By: rsmith Subscribers: aaron.ballman, riccibruno, calabrese, titus, cfe-commits Differential Revision: https://reviews.llvm.org/D55534 llvm-svn: 348977
2018-12-13 05:50:55 +08:00
REGISTER_MATCHER(usesADL);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(usingDecl);
Add missing matchers to the dynamic registry. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D4910 llvm-svn: 215757
2014-08-16 03:13:27 +08:00
REGISTER_MATCHER(usingDirectiveDecl);
Add valueDecl() matcher. Summary: Add valueDecl() matcher. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D6005 llvm-svn: 220776
2014-10-28 21:33:58 +08:00
REGISTER_MATCHER(valueDecl);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(varDecl);
Parser/Registry argument enhancements. Summary: Parser/Registry argument enhancements. - 2 argument support. - unsigned values support. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D915 llvm-svn: 183231
2013-06-04 23:46:22 +08:00
REGISTER_MATCHER(variableArrayType);
Add voidType() matcher. Summary: Add voidType() matcher. Reviewers: klimek Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D6656 llvm-svn: 224250
2014-12-15 23:09:22 +08:00
REGISTER_MATCHER(voidType);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
REGISTER_MATCHER(whileStmt);
Add CXXCtorInitializer related matchers to the dynamic matcher registry. Summary: Now that CXXCtorInitializer is already supported in ASTNodeKind, add CXXCtorInitializer matchers to the dynamic matcher registry. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1158 llvm-svn: 186508
2013-07-17 22:28:00 +08:00
REGISTER_MATCHER(withInitializer);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
}
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
RegistryMaps::~RegistryMaps() = default;
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
static llvm::ManagedStatic<RegistryMaps> RegistryData;
// static
Add support for named values in the parser. Summary: Add support for named values in the parser. Reviewers: pcc CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D3276 llvm-svn: 206176
2014-04-14 21:51:21 +08:00
llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
auto it = RegistryData->constructors().find(MatcherName);
Add support for named values in the parser. Summary: Add support for named values in the parser. Reviewers: pcc CC: cfe-commits, klimek Differential Revision: http://llvm-reviews.chandlerc.com/D3276 llvm-svn: 206176
2014-04-14 21:51:21 +08:00
return it == RegistryData->constructors().end()
? llvm::Optional<MatcherCtor>()
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
: it->second.get();
Split registry matcher resolution into a lookup phase and a construction phase. The looked-up matchers will be used during code completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2207 llvm-svn: 195534
2013-11-23 09:13:16 +08:00
}
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const std::set<ASTNodeKind> &KS) {
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
unsigned Count = 0;
for (std::set<ASTNodeKind>::const_iterator I = KS.begin(), E = KS.end();
I != E; ++I) {
if (I != KS.begin())
OS << "|";
if (Count++ == 3) {
OS << "...";
break;
}
OS << *I;
}
return OS;
}
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
std::vector<ArgKind> Registry::getAcceptedCompletionTypes(
ArrayRef<std::pair<MatcherCtor, unsigned>> Context) {
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
ASTNodeKind InitialTypes[] = {
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
ASTNodeKind::getFromNodeKind<Decl>(),
ASTNodeKind::getFromNodeKind<QualType>(),
ASTNodeKind::getFromNodeKind<Type>(),
ASTNodeKind::getFromNodeKind<Stmt>(),
ASTNodeKind::getFromNodeKind<NestedNameSpecifier>(),
ASTNodeKind::getFromNodeKind<NestedNameSpecifierLoc>(),
ASTNodeKind::getFromNodeKind<TypeLoc>()};
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
// Starting with the above seed of acceptable top-level matcher types, compute
// the acceptable type set for the argument indicated by each context element.
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
std::set<ArgKind> TypeSet(std::begin(InitialTypes), std::end(InitialTypes));
for (const auto &CtxEntry : Context) {
MatcherCtor Ctor = CtxEntry.first;
unsigned ArgNumber = CtxEntry.second;
std::vector<ArgKind> NextTypeSet;
for (const ArgKind &Kind : TypeSet) {
if (Kind.getArgKind() == Kind.AK_Matcher &&
Ctor->isConvertibleTo(Kind.getMatcherKind()) &&
(Ctor->isVariadic() || ArgNumber < Ctor->getNumArgs()))
Ctor->getArgKinds(Kind.getMatcherKind(), ArgNumber, NextTypeSet);
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
}
TypeSet.clear();
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
TypeSet.insert(NextTypeSet.begin(), NextTypeSet.end());
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
}
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
return std::vector<ArgKind>(TypeSet.begin(), TypeSet.end());
}
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
std::vector<MatcherCompletion>
Registry::getMatcherCompletions(ArrayRef<ArgKind> AcceptedTypes) {
std::vector<MatcherCompletion> Completions;
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
// Search the registry for acceptable matchers.
RangRangify some more for loops; NFC. llvm-svn: 244792
2015-08-13 03:00:39 +08:00
for (const auto &M : RegistryData->constructors()) {
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
const MatcherDescriptor& Matcher = *M.getValue();
RangRangify some more for loops; NFC. llvm-svn: 244792
2015-08-13 03:00:39 +08:00
StringRef Name = M.getKey();
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
std::set<ASTNodeKind> RetKinds;
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
unsigned NumArgs = Matcher.isVariadic() ? 1 : Matcher.getNumArgs();
bool IsPolymorphic = Matcher.isPolymorphic();
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
std::vector<std::vector<ArgKind>> ArgsKinds(NumArgs);
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
unsigned MaxSpecificity = 0;
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
for (const ArgKind& Kind : AcceptedTypes) {
if (Kind.getArgKind() != Kind.AK_Matcher)
continue;
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
unsigned Specificity;
ASTNodeKind LeastDerivedKind;
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
if (Matcher.isConvertibleTo(Kind.getMatcherKind(), &Specificity,
&LeastDerivedKind)) {
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
if (MaxSpecificity < Specificity)
MaxSpecificity = Specificity;
RetKinds.insert(LeastDerivedKind);
for (unsigned Arg = 0; Arg != NumArgs; ++Arg)
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
Matcher.getArgKinds(Kind.getMatcherKind(), Arg, ArgsKinds[Arg]);
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
if (IsPolymorphic)
break;
}
}
if (!RetKinds.empty() && MaxSpecificity > 0) {
std::string Decl;
llvm::raw_string_ostream OS(Decl);
if (IsPolymorphic) {
RangRangify some more for loops; NFC. llvm-svn: 244792
2015-08-13 03:00:39 +08:00
OS << "Matcher<T> " << Name << "(Matcher<T>";
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
} else {
RangRangify some more for loops; NFC. llvm-svn: 244792
2015-08-13 03:00:39 +08:00
OS << "Matcher<" << RetKinds << "> " << Name << "(";
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
for (const std::vector<ArgKind> &Arg : ArgsKinds) {
if (&Arg != &ArgsKinds[0])
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
OS << ", ";
Fix completion logic to allow for heterogeneous argument types in matcher overloads. Summary: There was an assumption that there were no matchers that were overloaded on matchers and other types of arguments. This assumption was broken recently with the addition of new matcher overloads. Fixes http://llvm.org/PR21226 Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D5711 llvm-svn: 219450
2014-10-10 06:08:52 +08:00
bool FirstArgKind = true;
std::set<ASTNodeKind> MatcherKinds;
// Two steps. First all non-matchers, then matchers only.
for (const ArgKind &AK : Arg) {
if (AK.getArgKind() == ArgKind::AK_Matcher) {
MatcherKinds.insert(AK.getMatcherKind());
} else {
if (!FirstArgKind) OS << "|";
FirstArgKind = false;
OS << AK.asString();
}
}
if (!MatcherKinds.empty()) {
if (!FirstArgKind) OS << "|";
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
OS << "Matcher<" << MatcherKinds << ">";
}
}
}
[AST] Convert Marshallers to use unique_ptr. Reviewers: timshen Subscribers: cfe-commits, klimek Differential Revision: https://reviews.llvm.org/D25425 llvm-svn: 283773
2016-10-11 00:26:40 +08:00
if (Matcher.isVariadic())
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
OS << "...";
OS << ")";
RangRangify some more for loops; NFC. llvm-svn: 244792
2015-08-13 03:00:39 +08:00
std::string TypedText = Name;
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
TypedText += "(";
if (ArgsKinds.empty())
TypedText += ")";
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
else if (ArgsKinds[0][0].getArgKind() == ArgKind::AK_String)
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
TypedText += "\"";
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
Completions.emplace_back(TypedText, OS.str(), MaxSpecificity);
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
}
}
Support named values in the autocomplete feature. Summary: This includes: - Passing a Sema to completeExpression to allow for named values in the expression. - Passing a map of names to values to the parser. - Update the Sema interface to include completion for matchers. - Change the parser to use the Sema for completion, instead of going directly to Registry. Reviewers: pcc Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D3509 llvm-svn: 215472
2014-08-13 05:11:37 +08:00
return Completions;
Introduce Registry::getCompletions. This returns a list of valid (and useful) completions for a context (a list of outer matchers), ordered by decreasing relevance then alphabetically. It will be used by the matcher parser to implement completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2210 llvm-svn: 199950
2014-01-24 06:48:38 +08:00
}
Split registry matcher resolution into a lookup phase and a construction phase. The looked-up matchers will be used during code completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2207 llvm-svn: 195534
2013-11-23 09:13:16 +08:00
VariantMatcher Registry::constructMatcher(MatcherCtor Ctor,
SourceRanges are small and trivially copyable, don't them by reference. llvm-svn: 249259
2015-10-04 12:53:55 +08:00
SourceRange NameRange,
Split registry matcher resolution into a lookup phase and a construction phase. The looked-up matchers will be used during code completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2207 llvm-svn: 195534
2013-11-23 09:13:16 +08:00
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
Rename *MatcherCreateCallback to *MatcherDescriptor, and its member run() to create(). The new names will be more appropriate when the objects are taught to return type information for the code completer. Differential Revision: http://llvm-reviews.chandlerc.com/D2208 llvm-svn: 195539
2013-11-23 09:34:36 +08:00
return Ctor->create(NameRange, Args, Error);
First revision of the dynamic ASTMatcher library. This library supports all the features of the compile-time based ASTMatcher library, but allows the user to specify and construct the matchers at runtime. It contains the following modules: - A variant type, to be used by the matcher factory. - A registry, where the matchers are indexed by name and have a factory method with a generic signature. - A simple matcher expression parser, that can be used to convert a matcher expression string into actual matchers that can be used with the AST at runtime. Many features where omitted from this first revision to simplify this code review. The main ideas are still represented in this change and it already has support working use cases. Things that are missing: - Support for polymorphic matchers. These requires supporting code in the registry, the marshallers and the variant type. - Support for numbers, char and bool arguments to the matchers. This requires supporting code in the parser and the variant type. - A command line program putting everything together and providing an already functional tool. Patch by Samuel Benzaquen. llvm-svn: 181768
2013-05-14 17:13:00 +08:00
}
Split registry matcher resolution into a lookup phase and a construction phase. The looked-up matchers will be used during code completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2207 llvm-svn: 195534
2013-11-23 09:13:16 +08:00
VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,
SourceRanges are small and trivially copyable, don't them by reference. llvm-svn: 249259
2015-10-04 12:53:55 +08:00
SourceRange NameRange,
Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. Summary: Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. This work is to support future changes needed for eachOf/allOf/anyOf matchers. We will add a new type on VariantMatcher. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1365 llvm-svn: 188272
2013-08-13 22:54:51 +08:00
StringRef BindID,
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
Split registry matcher resolution into a lookup phase and a construction phase. The looked-up matchers will be used during code completion. Differential Revision: http://llvm-reviews.chandlerc.com/D2207 llvm-svn: 195534
2013-11-23 09:13:16 +08:00
VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. Summary: Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. This work is to support future changes needed for eachOf/allOf/anyOf matchers. We will add a new type on VariantMatcher. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1365 llvm-svn: 188272
2013-08-13 22:54:51 +08:00
if (Out.isNull()) return Out;
Resubmit "Refactor DynTypedMatcher into a value type class, just like Matcher<T>." Summary: This resubmits r193100, plus a fix for a breakage with MSVC. Reviewers: klimek, rnk CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D2005 llvm-svn: 193613
2013-10-29 22:37:15 +08:00
llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
if (Result.hasValue()) {
llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
if (Bound.hasValue()) {
Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. Summary: Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. This work is to support future changes needed for eachOf/allOf/anyOf matchers. We will add a new type on VariantMatcher. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1365 llvm-svn: 188272
2013-08-13 22:54:51 +08:00
return VariantMatcher::SingleMatcher(*Bound);
Add support for polymorphic matchers. Use runtime type checking to determine the right polymorphic overload to use. llvm-svn: 184558
2013-06-21 23:51:31 +08:00
}
Add support for .bind("foo") expressions on the dynamic matchers. Summary: Add support on the parser, registry, and DynTypedMatcher for binding IDs dynamically. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D911 llvm-svn: 183144
2013-06-04 03:31:08 +08:00
}
Separate the notion of 'context' when recursing down in the parser and actual errors. Summary: Change how error messages are constructed and stored in Diagnostics. Separate the notion of 'context' when recursing down in the parser and actual errors. This will simplify adding some new features, like argument overloading and error recovery. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1168 llvm-svn: 186602
2013-07-19 03:47:59 +08:00
Error->addError(NameRange, Error->ET_RegistryNotBindable);
Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. Summary: Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case. This work is to support future changes needed for eachOf/allOf/anyOf matchers. We will add a new type on VariantMatcher. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D1365 llvm-svn: 188272
2013-08-13 22:54:51 +08:00
return VariantMatcher();
Add support for .bind("foo") expressions on the dynamic matchers. Summary: Add support on the parser, registry, and DynTypedMatcher for binding IDs dynamically. Reviewers: klimek CC: cfe-commits, revane Differential Revision: http://llvm-reviews.chandlerc.com/D911 llvm-svn: 183144
2013-06-04 03:31:08 +08:00
}
[ASTMatchers] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 317137
2017-11-02 07:09:49 +08:00
} // namespace dynamic
} // namespace ast_matchers
} // namespace clang