reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

gen/tools/clang/include/clang/AST/StmtNodes.inc
  121 IFSTMT(IfStmt, Stmt)

References

include/llvm/ADT/STLExtras.h
   75       typename std::add_pointer<typename std::add_const<T>::type>::type;
include/llvm/Support/Casting.h
   58     return To::classof(&Val);
   77     return isa_impl<To, From>::doit(Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  168   using ret_type = const To &; // Normal case, return Ty&
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/TrailingObjects.h
  134     : public TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy,
  137   typedef TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy, MoreTys...>
  141     static const bool value = alignof(PrevTy) < alignof(NextTy);
  162   getTrailingObjectsImpl(const BaseTy *Obj,
  177   getTrailingObjectsImpl(BaseTy *Obj,
  179     auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
  232                             BaseTy, TrailingObjects<BaseTy, TrailingTys...>,
  232                             BaseTy, TrailingObjects<BaseTy, TrailingTys...>,
  233                             BaseTy, TrailingTys...> {
  242       BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
  242       BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
  242       BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
  257   static const BaseTy *
  258   getTrailingObjectsImpl(const BaseTy *Obj,
  259                          TrailingObjectsBase::OverloadToken<BaseTy>) {
  263   static BaseTy *
  264   getTrailingObjectsImpl(BaseTy *Obj,
  265                          TrailingObjectsBase::OverloadToken<BaseTy>) {
  277   callNumTrailingObjects(const BaseTy *Obj,
  278                          TrailingObjectsBase::OverloadToken<BaseTy>) {
  283   static size_t callNumTrailingObjects(const BaseTy *Obj,
  284                                        TrailingObjectsBase::OverloadToken<T>) {
  345     return sizeof(BaseTy) + ParentType::additionalSizeToAllocImpl(0, Counts...);
tools/clang/include/clang/AST/ASTContext.h
  664   template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
tools/clang/include/clang/AST/ASTTypeTraits.h
   65     return ASTNodeKind(KindToKindId<T>::Id);
  234   static DynTypedNode create(const T &Node) {
  235     return BaseConverter<T>::create(Node);
  251   const T *get() const {
  252     return BaseConverter<T>::get(NodeKind, Storage.buffer);
  259   const T &getUnchecked() const {
  260     return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
  394     static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
  395       if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
  399     static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
  401       return *cast<T>(static_cast<const BaseT *>(
  474     : public DynCastPtrConverter<T, Stmt> {};
tools/clang/include/clang/AST/JSONNodeDumper.h
  302   void VisitIfStmt(const IfStmt *IS);
tools/clang/include/clang/AST/Stmt.h
 1824       private llvm::TrailingObjects<IfStmt, Stmt *, SourceLocation> {
 1878   static IfStmt *Create(const ASTContext &Ctx, SourceLocation IL,
 1885   static IfStmt *CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar,
tools/clang/include/clang/AST/TextNodeDumper.h
  225   void VisitIfStmt(const IfStmt *Node);
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h
  266 const NodeT *
  269     if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
  269     if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
tools/clang/include/clang/ASTMatchers/ASTMatchers.h
  110   const T *getNodeAs(StringRef ID) const {
  111     return MyBoundNodes.getNodeAs<T>(ID);
 1829 extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
  160   const T *getNodeAs(StringRef ID) const {
  165     return It->second.get<T>();
  302   virtual bool matches(const T &Node,
  309     return matches(DynNode.getUnchecked<T>(), Finder, Builder);
  345   DynTypedMatcher(MatcherInterface<T> *Implementation)
  346       : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
  436     return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  445   template <typename T> Matcher<T> convertTo() const {
  447     return unconditionalConvertTo<T>();
  479 class WrapperMatcherInterface : public MatcherInterface<T> {
  499   explicit Matcher(MatcherInterface<T> *Implementation)
  507           typename std::enable_if<std::is_base_of<From, T>::value &&
  508                                !std::is_same<From, T>::value>::type * = nullptr)
  520             std::is_same<T, QualType>::value &&
  529     static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
  534   bool matches(const T &Node,
  581     return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
  596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
  994   bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
  997     static_assert(std::is_base_of<Decl, T>::value ||
  998                   std::is_base_of<Stmt, T>::value ||
  999                   std::is_base_of<NestedNameSpecifier, T>::value ||
 1000                   std::is_base_of<NestedNameSpecifierLoc, T>::value ||
 1001                   std::is_base_of<TypeLoc, T>::value ||
 1002                   std::is_base_of<QualType, T>::value,
 1026   bool matchesAncestorOf(const T &Node,
 1030     static_assert(std::is_base_of<Decl, T>::value ||
 1031                       std::is_base_of<NestedNameSpecifierLoc, T>::value ||
 1032                       std::is_base_of<Stmt, T>::value ||
 1033                       std::is_base_of<TypeLoc, T>::value,
 1067   using head = T1;
 1073   using tail = TypeList<Ts...>;
 1084       std::is_base_of<typename AnyTypeList::head, T>::value ||
 1085       TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
 1146     template <typename To> operator Matcher<To>() const {
 1184   operator Matcher<T>() const {
 1185     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
 1202   operator Matcher<T>() const {
 1203     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
 1243   operator Matcher<T>() const {
 1245                ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
 1246         .template unconditionalConvertTo<T>();
 1255 class BindableMatcher : public Matcher<T> {
 1257   explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
 1258   explicit BindableMatcher(MatcherInterface<T> *Implementation)
 1265   Matcher<T> bind(StringRef ID) const {
 1285 class HasMatcher : public WrapperMatcherInterface<T> {
 1290   bool matches(const T &Node, ASTMatchFinder *Finder,
 1335   template <typename T> operator Matcher<T>() const {
 1337                Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
 1338                getMatchers<T>(std::index_sequence_for<Ps...>()))
 1339         .template unconditionalConvertTo<T>();
 1370 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
 1376 BindableMatcher<T> makeAllOfComposite(
 1377     ArrayRef<const Matcher<T> *> InnerMatchers) {
 1388   using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
 1395           ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
 1397           .template unconditionalConvertTo<T>());
 1408     ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
 1438 class HasParentMatcher : public WrapperMatcherInterface<T> {
 1446   bool matches(const T &Node, ASTMatchFinder *Finder,
 1458 class HasAncestorMatcher : public WrapperMatcherInterface<T> {
 1466   bool matches(const T &Node, ASTMatchFinder *Finder,
 1557     : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
 1558                               makeDynCastAllOfComposite<SourceT, TargetT>> {
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
  199   ast_matchers::internal::Matcher<T> getTypedMatcher() const {
  202         ->template convertTo<T>();
  227       : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
  228   typedef ast_matchers::internal::Matcher<T> MatcherT;
  232     return DynTypedMatcher(Matcher.convertTo<T>());
tools/clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp
   95   bool VisitIfStmt(IfStmt *S) {
tools/clang/lib/ARCMigrate/Transforms.cpp
  262   bool VisitIfStmt(IfStmt *S) {
tools/clang/lib/AST/ASTImporter.cpp
  515     ExpectedStmt VisitIfStmt(IfStmt *S);
 5830 ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
 5845   return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(),
tools/clang/lib/AST/ExprConstant.cpp
 4491       const IfStmt *IS = cast<IfStmt>(S);
 4491       const IfStmt *IS = cast<IfStmt>(S);
 4647     const IfStmt *IS = cast<IfStmt>(S);
 4647     const IfStmt *IS = cast<IfStmt>(S);
tools/clang/lib/AST/Interp/ByteCodeStmtGen.cpp
  124     return visitIfStmt(cast<IfStmt>(S));
  191 bool ByteCodeStmtGen<Emitter>::visitIfStmt(const IfStmt *IS) {
tools/clang/lib/AST/Interp/ByteCodeStmtGen.h
   64   bool visitIfStmt(const IfStmt *IS);
tools/clang/lib/AST/JSONNodeDumper.cpp
 1416 void JSONNodeDumper::VisitIfStmt(const IfStmt *IS) {
tools/clang/lib/AST/ParentMap.cpp
  203       return DirectChild == cast<IfStmt>(P)->getCond();
tools/clang/lib/AST/Stmt.cpp
  863 IfStmt *IfStmt::Create(const ASTContext &Ctx, SourceLocation IL,
  872       alignof(IfStmt));
  874       IfStmt(Ctx, IL, IsConstexpr, Init, Var, Cond, Then, EL, Else);
  877 IfStmt *IfStmt::CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar,
  882       alignof(IfStmt));
  883   return new (Mem) IfStmt(EmptyShell(), HasElse, HasVar, HasInit);
tools/clang/lib/AST/StmtPrinter.cpp
  127     void PrintRawIfStmt(IfStmt *If);
  241 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
  268     } else if (auto *ElseIf = dyn_cast<IfStmt>(Else)) {
  268     } else if (auto *ElseIf = dyn_cast<IfStmt>(Else)) {
  278 void StmtPrinter::VisitIfStmt(IfStmt *If) {
tools/clang/lib/AST/StmtProfile.cpp
  262 void StmtProfiler::VisitIfStmt(const IfStmt *S) {
tools/clang/lib/AST/TextNodeDumper.cpp
  651 void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
  693 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h
   75     return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
   78   static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
   79     return Value.getMatcher().getTypedMatcher<T>();
   83     return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  361     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  466       ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
  469         DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
  778     ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
tools/clang/lib/Analysis/BodyFarm.cpp
  465   auto *Out =
  466       IfStmt::Create(C, SourceLocation(),
  550   auto *If = IfStmt::Create(C, SourceLocation(),
  550   auto *If = IfStmt::Create(C, SourceLocation(),
  658   auto *If = IfStmt::Create(C, SourceLocation(),
  658   auto *If = IfStmt::Create(C, SourceLocation(),
tools/clang/lib/Analysis/CFG.cpp
  577   CFGBlock *VisitIfStmt(IfStmt *I);
 2240       return VisitIfStmt(cast<IfStmt>(S));
 2902 CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) {
 5091               const VarDecl *var = cast<IfStmt>(stmt)->getConditionVariable();
 5181   void VisitIfStmt(IfStmt *I) {
 5923       E = cast<IfStmt>(Terminator)->getCond();
tools/clang/lib/Analysis/Consumed.cpp
  935 static void splitVarStateForIf(const IfStmt *IfNode, const VarTestResult &Test,
 1234   if (const auto *IfNode =
 1235           dyn_cast_or_null<IfStmt>(CurrBlock->getTerminator().getStmt())) {
tools/clang/lib/Analysis/LiveVariables.cpp
  334       AddLiveStmt(val.liveStmts, LV.SSetFact, cast<IfStmt>(S)->getCond());
tools/clang/lib/CodeGen/Address.h
  108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGStmt.cpp
  139   case Stmt::IfStmtClass:      EmitIfStmt(cast<IfStmt>(*S));              break;
  632 void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
tools/clang/lib/CodeGen/CodeGenFunction.cpp
 1310   if (isa<IfStmt>(S) || isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
tools/clang/lib/CodeGen/CodeGenFunction.h
 2874   void EmitIfStmt(const IfStmt &S);
tools/clang/lib/CodeGen/CodeGenPGO.cpp
  212   bool TraverseIfStmt(IfStmt *If) {
  631   void VisitIfStmt(const IfStmt *S) {
tools/clang/lib/CodeGen/CoverageMappingGen.cpp
 1169   void VisitIfStmt(const IfStmt *S) {
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp
  869       const IfStmt *IS = cast<IfStmt>(Term);
  869       const IfStmt *IS = cast<IfStmt>(Term);
tools/clang/lib/Sema/JumpDiagnostics.cpp
  358     IfStmt *IS = cast<IfStmt>(S);
  358     IfStmt *IS = cast<IfStmt>(S);
tools/clang/lib/Sema/SemaDeclAttr.cpp
 8133     return cast<IfStmt>(Parent)->getThen() == S ||
 8134            cast<IfStmt>(Parent)->getElse() == S;
 8237   bool TraverseIfStmt(IfStmt *If);
 8429 bool DiagnoseUnguardedAvailability::TraverseIfStmt(IfStmt *If) {
tools/clang/lib/Sema/SemaDeclCXX.cpp
 2019     IfStmt *If = cast<IfStmt>(S);
 2019     IfStmt *If = cast<IfStmt>(S);
tools/clang/lib/Sema/SemaStmt.cpp
  599   return IfStmt::Create(Context, IfLoc, IsConstexpr, InitStmt, Cond.get().first,
tools/clang/lib/Sema/TreeTransform.h
 6817 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
tools/clang/lib/Serialization/ASTReaderStmt.cpp
  219 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
 2528       S = IfStmt::CreateEmpty(
tools/clang/lib/Serialization/ASTWriterStmt.cpp
  132 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
tools/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp
   49   bool VisitIfStmt(const IfStmt *I);
  106 bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) {
  117       const IfStmt *InnerIf = dyn_cast<IfStmt>(*CS->body_begin());
  117       const IfStmt *InnerIf = dyn_cast<IfStmt>(*CS->body_begin());
  138     while (const IfStmt *I2 = dyn_cast_or_null<IfStmt>(Else)) {
  138     while (const IfStmt *I2 = dyn_cast_or_null<IfStmt>(Else)) {
  416     const IfStmt *IStmt1 = cast<IfStmt>(Stmt1);
  416     const IfStmt *IStmt1 = cast<IfStmt>(Stmt1);
  417     const IfStmt *IStmt2 = cast<IfStmt>(Stmt2);
  417     const IfStmt *IStmt2 = cast<IfStmt>(Stmt2);
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
 1215     bool VisitIfStmt(const IfStmt *I);
 1216     bool EndVisitIfStmt(IfStmt *I);
 1217     bool TraverseIfStmt(IfStmt *x);
 1319 bool PluralMisuseChecker::MethodCrawler::TraverseIfStmt(IfStmt *I) {
 1327 bool PluralMisuseChecker::MethodCrawler::EndVisitIfStmt(IfStmt *I) {
 1339 bool PluralMisuseChecker::MethodCrawler::VisitIfStmt(const IfStmt *I) {
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp
  681         if (cast<IfStmt>(Parent)->getCond() != S)
 1362       return cast<IfStmt>(S)->getCond() == Cond;
 1541           isa<IfStmt>(s1Start) || isa<ObjCForCollectionStmt>(s1Start) ||
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
 2215     Cond = cast<IfStmt>(Term)->getCond();
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp
  359         HandleBranch(cast<IfStmt>(Term)->getCond(), Term, B, Pred);
tools/clang/lib/Tooling/Refactoring/Extract/SourceExtraction.cpp
   32   if (const auto *If = dyn_cast<IfStmt>(S))
   32   if (const auto *If = dyn_cast<IfStmt>(S))
tools/clang/lib/Tooling/RefactoringCallbacks.cpp
  128   if (const IfStmt *Node = Result.Nodes.getNodeAs<IfStmt>(Id)) {
  128   if (const IfStmt *Node = Result.Nodes.getNodeAs<IfStmt>(Id)) {
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp
  241     if (const auto *Arg = N->get<T>())
  241     if (const auto *Arg = N->get<T>())
  296 CharSourceRange getElseRange(const MatchResult &Result, const IfStmt &S) {
tools/clang/tools/extra/clang-tidy/bugprone/BoolPointerImplicitConversionCheck.cpp
   34   auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
tools/clang/tools/extra/clang-tidy/bugprone/BranchCloneCheck.cpp
   73   if (const auto *IS = Result.Nodes.getNodeAs<IfStmt>("if")) {
   73   if (const auto *IS = Result.Nodes.getNodeAs<IfStmt>("if")) {
   80     if (!isa<IfStmt>(Else)) {
   93     const IfStmt *Cur = IS;
  104       Cur = dyn_cast<IfStmt>(Else);
tools/clang/tools/extra/clang-tidy/bugprone/MultipleStatementMacroCheck.cpp
   77     OuterLoc = cast<IfStmt>(Outer)->getElseLoc();
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousSemicolonCheck.cpp
   48   const bool IsIfStmt = isa<IfStmt>(Statement);
tools/clang/tools/extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp
   93   if (const auto *ElseIfWithoutElse =
   94           Result.Nodes.getNodeAs<IfStmt>("else-if")) {
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.cpp
  804       if (isa<IfStmt>(CurrStmtParent) || isa<WhileStmt>(CurrStmtParent) ||
tools/clang/tools/extra/clang-tidy/readability/BracesAroundStatementsCheck.cpp
  150   } else if (auto S = Result.Nodes.getNodeAs<IfStmt>("if")) {
  160     if (Else && !isa<IfStmt>(Else)) {
tools/clang/tools/extra/clang-tidy/readability/BracesAroundStatementsCheck.h
   56   SourceLocation findRParenLoc(const IfOrWhileStmt *S, const SourceManager &SM,
tools/clang/tools/extra/clang-tidy/readability/DeleteNullPointerCheck.cpp
   54   const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete");
   54   const auto *IfWithDelete = Result.Nodes.getNodeAs<IfStmt>("ifWithDelete");
tools/clang/tools/extra/clang-tidy/readability/ElseAfterReturnCheck.cpp
   43   const auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
   43   const auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
tools/clang/tools/extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp
  229       if (isa<IfStmt>(S) || isa<ConditionalOperator>(S) || isa<ForStmt>(S) ||
tools/clang/tools/extra/clang-tidy/readability/MisleadingIndentationCheck.cpp
   19 static const IfStmt *getPrecedingIf(const SourceManager &SM,
   20                                     ASTContext *Context, const IfStmt *If) {
   24   if (const auto *PrecedingIf = parents[0].get<IfStmt>()) {
   24   if (const auto *PrecedingIf = parents[0].get<IfStmt>()) {
   35                                                    const IfStmt *If) {
   64     if (const auto *CurrentIf = dyn_cast<IfStmt>(CurrentStmt)) {
   64     if (const auto *CurrentIf = dyn_cast<IfStmt>(CurrentStmt)) {
  117   if (const auto *If = Result.Nodes.getNodeAs<IfStmt>("if"))
  117   if (const auto *If = Result.Nodes.getNodeAs<IfStmt>("if"))
tools/clang/tools/extra/clang-tidy/readability/MisleadingIndentationCheck.h
   33                          const IfStmt *If);
tools/clang/tools/extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp
  281 const CXXBoolLiteralExpr *stmtReturnsBool(const IfStmt *IfRet, bool Negated) {
  540   else if (const auto *If = Result.Nodes.getNodeAs<IfStmt>(IfReturnsBoolId))
  540   else if (const auto *If = Result.Nodes.getNodeAs<IfStmt>(IfReturnsBoolId))
  542   else if (const auto *IfNot =
  543                Result.Nodes.getNodeAs<IfStmt>(IfReturnsNotBoolId))
  545   else if (const auto *IfAssign =
  546                Result.Nodes.getNodeAs<IfStmt>(IfAssignBoolId))
  548   else if (const auto *IfAssignNot =
  549                Result.Nodes.getNodeAs<IfStmt>(IfAssignNotBoolId))
  575   const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
  575   const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
  584   const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
  584   const auto *IfStatement = Result.Nodes.getNodeAs<IfStmt>(IfStmtId);
  602     const MatchFinder::MatchResult &Result, const IfStmt *If, bool Negated) {
  624   const IfStmt *BeforeIf = nullptr;
  629     if (const auto *If = dyn_cast<IfStmt>(*Current)) {
  629     if (const auto *If = dyn_cast<IfStmt>(*Current)) {
  653     const MatchFinder::MatchResult &Result, const IfStmt *IfAssign,
tools/clang/tools/extra/clang-tidy/readability/SimplifyBooleanExprCheck.h
   66       const ast_matchers::MatchFinder::MatchResult &Result, const IfStmt *If,
   71                         const IfStmt *If, bool Negated = false);
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.cpp
  146     } else if (const auto *TheIfStmt = dyn_cast<IfStmt>(Parent)) {
  146     } else if (const auto *TheIfStmt = dyn_cast<IfStmt>(Parent)) {
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp
  135              isa<DoStmt>(Stmt) || isa<ForStmt>(Stmt) || isa<IfStmt>(Stmt) ||
  356   if (const auto* IS = llvm::dyn_cast<IfStmt>(Outer))
  356   if (const auto* IS = llvm::dyn_cast<IfStmt>(Outer))
tools/clang/tools/extra/clangd/refactor/tweaks/SwapIfBranches.cpp
   45   const IfStmt *If = nullptr;
   56     If = dyn_cast_or_null<IfStmt>(N->ASTNode.get<Stmt>());
tools/clang/tools/extra/unittests/clang-tidy/OverlappingReplacementsTest.cpp
   50     auto *If = Result.Nodes.getNodeAs<IfStmt>(BoundIf);
tools/clang/tools/libclang/CIndex.cpp
 1995   void VisitIfStmt(const IfStmt *If);
 2620 void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp
   25   return ASTNodeKind::getFromNodeKind<T>();
tools/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
 1542     const T *Node = Nodes->getNodeAs<T>("");
 1542     const T *Node = Nodes->getNodeAs<T>("");
 1549     const T *TypedNode = cast<T>(Node);
 1549     const T *TypedNode = cast<T>(Node);
 1550     return selectFirst<T>(
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h
  421     if (Nodes->getNodeAs<T>(Id)) {
tools/clang/unittests/Tooling/ASTSelectionTest.cpp
  107           typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type
  107           typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type
  109   checkNodeImpl(isa<T>(StmtNode.Node.get<Stmt>()), StmtNode, SelectionKind,
  323         allChildrenOf(checkNode<IfStmt>(Body.Children[1],
  343         checkNode<IfStmt>(Body.Children[1],
  368         checkNode<IfStmt>(Body.Children[2],
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
 1447     : public __and_<is_destructible<_Tp>, integral_constant<bool,
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1580     { typedef _Tp const     type; };
 1629     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1955     { typedef _Tp     type; };
 1999     { typedef typename remove_reference<_Tp>::type*     type; };
 2003     : public __add_pointer_helper<_Tp>
 2157     { typedef _Tp type; };