reference, declaration → definition definition → references, declarations, derived classes, virtual overrides reference to multiple definitions → definitions unreferenced |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 | //===--- ASTLambda.h - Lambda Helper Functions --------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file provides some common utility functions for processing /// Lambda related AST Constructs. /// //===----------------------------------------------------------------------===// #ifndef LLVM_CLANG_AST_ASTLAMBDA_H #define LLVM_CLANG_AST_ASTLAMBDA_H #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclTemplate.h" namespace clang { inline StringRef getLambdaStaticInvokerName() { return "__invoke"; } // This function returns true if M is a specialization, a template, // or a non-generic lambda call operator. inline bool isLambdaCallOperator(const CXXMethodDecl *MD) { const CXXRecordDecl *LambdaClass = MD->getParent(); if (!LambdaClass || !LambdaClass->isLambda()) return false; return MD->getOverloadedOperator() == OO_Call; } inline bool isLambdaCallOperator(const DeclContext *DC) { if (!DC || !isa<CXXMethodDecl>(DC)) return false; return isLambdaCallOperator(cast<CXXMethodDecl>(DC)); } inline bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD) { if (!MD) return false; const CXXRecordDecl *LambdaClass = MD->getParent(); if (LambdaClass && LambdaClass->isGenericLambda()) return isLambdaCallOperator(MD) && MD->isFunctionTemplateSpecialization(); return false; } inline bool isLambdaConversionOperator(CXXConversionDecl *C) { return C ? C->getParent()->isLambda() : false; } inline bool isLambdaConversionOperator(Decl *D) { if (!D) return false; if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) return isLambdaConversionOperator(Conv); if (FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(D)) if (CXXConversionDecl *Conv = dyn_cast_or_null<CXXConversionDecl>(F->getTemplatedDecl())) return isLambdaConversionOperator(Conv); return false; } inline bool isGenericLambdaCallOperatorSpecialization(DeclContext *DC) { return isGenericLambdaCallOperatorSpecialization( dyn_cast<CXXMethodDecl>(DC)); } // This returns the parent DeclContext ensuring that the correct // parent DeclContext is returned for Lambdas inline DeclContext *getLambdaAwareParentOfDeclContext(DeclContext *DC) { if (isLambdaCallOperator(DC)) return DC->getParent()->getParent(); else return DC->getParent(); } } // clang #endif |